diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,1372 @@
+# Hydra changelog
+
+All notable changes to the Hydra project are documented in this file.
+
+This changelog tracks changes across all Hydra implementations
+(Haskell, Java, Python, Scala, TypeScript, Clojure, Common Lisp, Emacs Lisp, Scheme)
+and supporting infrastructure.
+
+The format is inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and [Apache TinkerPop](https://github.com/apache/tinkerpop/blob/master/CHANGELOG.asciidoc).
+
+Pre-1.0 versions are listed below.
+Untagged versions correspond to in-repository version bumps that were not pushed as Git tags or Hackage releases;
+they are documented here for completeness.
+
+---
+
+## [0.17.0] - 2026-07-01
+
+Major themes: first-class support for effects and I/O in the kernel, TypeScript and
+Scala reaching publishable parity with the other hosts, and continued maturation of
+the published-host build model.
+
+### Highlights
+
+- **Effects and I/O** ([#286](https://github.com/CategoricalData/hydra/issues/286),
+  [#288](https://github.com/CategoricalData/hydra/issues/288),
+  [#494](https://github.com/CategoricalData/hydra/issues/494)): a new `effect` variant
+  on `hydra.core.Type` for representing effectful computations; new kernel modules
+  `hydra.file` (`FilePath`, `FileType`, `FileStatus`, `FileExtension`), `hydra.time`
+  (`Timespec`), and `hydra.error.file`; new primitive libraries `hydra.lib.effects`,
+  `hydra.lib.files`, and `hydra.lib.text` with byte-level I/O; and a new
+  `EffectfulTestCase` mechanism so the common test suite can exercise effectful
+  primitives across hosts.
+- **TypeScript is a complete implementation**
+  ([#462](https://github.com/CategoricalData/hydra/issues/462)): self-hosts and passes
+  the common test suite, with a per-package npm publish pipeline
+  ([#492](https://github.com/CategoricalData/hydra/issues/492)).
+- **Scala publishing**: per-package Maven Central publish infrastructure
+  ([#491](https://github.com/CategoricalData/hydra/issues/491)).
+- **Published-host build model**: published mode now compiles the kernel from the
+  co-generated `dist/haskell` rather than Hackage, removing the need for a
+  `haskell=local` shim ([#500](https://github.com/CategoricalData/hydra/issues/500));
+  the oil-and-water principle and cold-build workflow for `dist/haskell` are documented
+  ([#376](https://github.com/CategoricalData/hydra/issues/376)).
+- **Kernel hygiene**: `uniqueLabel` (apostrophe suffixes) replaced by `chooseUniqueLabel`
+  (numeric suffixes) in `hydra.names`
+  ([#436](https://github.com/CategoricalData/hydra/issues/436)).
+
+### Implementations
+
+Eight hosts self-host and pass the common test suite across five families: Haskell,
+Java, Python, Scala, and the four Lisp dialects (Clojure, Common Lisp, Scheme, Emacs
+Lisp), with TypeScript now joining as a complete host/target. Go remains a "head bud"
+(the coder still has emission bugs and the head's runtime is largely placeholder; it
+does not yet host the test suite).
+
+### New Features
+
+- Translingual cross-reference convention for `doc` strings: doc-escape tags render to
+  each host's native doc syntax (Javadoc, Haddock, Sphinx, TSDoc)
+  ([#433](https://github.com/CategoricalData/hydra/issues/433)).
+- Neo4j JSON-artifact validation demo, exercised across Java, Python, Haskell, and
+  TypeScript ([#510](https://github.com/CategoricalData/hydra/issues/510)).
+
+### Improvements
+
+- The Java/Maven publish set now covers every official Hydra target language, one coder
+  package per implementation family
+  ([#468](https://github.com/CategoricalData/hydra/issues/468)).
+- JVM Maven artifact groups are bifurcated to `net.fortytwo.hydra.java` and
+  `net.fortytwo.hydra.scala`, so the Java and Scala (and future Clojure) publish sets
+  never collide on coordinates
+  ([#519](https://github.com/CategoricalData/hydra/issues/519)).
+- Host-specific third-party integrations (the former `bindings/` tree) are folded into
+  `overlay/`, unifying hand-written host-native source under one tree
+  ([#511](https://github.com/CategoricalData/hydra/issues/511)).
+- The coder de-parameterizes context and error types, simplifying generated coder
+  signatures ([#518](https://github.com/CategoricalData/hydra/issues/518)).
+- TypeScript-to-Java generation now emits the `hydra.lib.*` aggregate namespace
+  interfaces (`Maps`, `Strings`, etc.)
+  ([#499](https://github.com/CategoricalData/hydra/issues/499)).
+
+---
+
+## [0.16.1] - 2026-06-16
+
+Major themes: the first release built by bootstrapping from previously published
+packages, the first full 9 × 9 cross-implementation bootstrapping sweep, and
+published-package self-containment fixes for the artifacts that bootstrap rests on.
+
+### Highlights
+
+- **Bootstrap from published packages**: the build links the published 0.16.0 hosts
+  (Hackage / Maven Central / PyPI) and uses them to build the next version of Hydra,
+  resting on 0.16.0's forward-compatibility guarantees — the published-host consume
+  model with a `--local-host` shim, used for the first time in a release
+  ([#370](https://github.com/CategoricalData/hydra/issues/370)). 0.16.1 still builds
+  against **local** Haskell and Python hosts (`hostOverrides`), because the published
+  0.16.0 artifacts it would otherwise consume are the very ones being repaired below.
+- **First full 9 × 9 bootstrapping sweep** — every implementation generating every
+  other; dozens of cross-host issues surfaced and fixed
+  ([#409](https://github.com/CategoricalData/hydra/issues/409), ongoing).
+- **Published-package self-containment**: relocate each host's hand-written runtime
+  into `overlay/<lang>/hydra-kernel/` so it ships inside the published `hydra-kernel`
+  artifact — Python `hydra.python.util` into the wheel
+  ([#461](https://github.com/CategoricalData/hydra/issues/461),
+  [#472](https://github.com/CategoricalData/hydra/issues/472)) and the Haskell
+  authoring DSL + `Libraries`/`Terms` into the sdist
+  ([#473](https://github.com/CategoricalData/hydra/issues/473)). Generalized to a
+  uniform `overlay/ = transform(packages) + copy(overlay)` model across all hosts
+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).
+- **Kernel self-containment via generated `hydra.lib.*` registries**: primitive
+  names are derived from generated `PrimitiveDefinition` def-modules rather than
+  hand-written name strings, in every host
+  ([#473](https://github.com/CategoricalData/hydra/issues/473)).
+- **In-memory encode/decode synthesis**: derived `hydra.{encode,decode}.*` modules
+  are synthesized at build time and excluded from `dist/`, with the synthesizer (not
+  inference) as the authority for their annotations
+  ([#448](https://github.com/CategoricalData/hydra/issues/448),
+  [#476](https://github.com/CategoricalData/hydra/issues/476)).
+- **Release hardening**: Apache source-release compliance (signed source archive,
+  LICENSE/NOTICE bundling, KEYS) ([#441](https://github.com/CategoricalData/hydra/issues/441)),
+  per-package publish orchestrators ([#449](https://github.com/CategoricalData/hydra/issues/449)),
+  and packaging-boundary verification gated in CI and at publish time
+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).
+
+### New features
+
+- Published-host consume model wired through `bin/sync.sh` for all three hosts
+  (`--published-host` default, `--local-host` shim), with the version basis keyed
+  off `hydra.json` and the `VERSION` file retired
+  ([#370](https://github.com/CategoricalData/hydra/issues/370),
+  [#347](https://github.com/CategoricalData/hydra/issues/347)).
+- Java and Python coder DSL sources made the sole source of truth; the legacy
+  Haskell DSL copies were deleted and cross-package references resolve by name
+  ([#346](https://github.com/CategoricalData/hydra/issues/346)).
+- Per-host `verify-distribution.sh` self-containment gates (Haskell stages the
+  per-package trio and `stack build`s it; Python installs the wheels into an
+  isolated venv and imports the kernel modules; Java resolves the published jars
+  from an offline consumer), run in CI and as a hard gate in `bin/prepare-release.sh`
+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).
+- Apache-compliant canonical source archive: signed + checksummed `git archive`
+  tarball as the release of record, root `NOTICE`, `KEYS`, and a release-verify CI
+  workflow ([#441](https://github.com/CategoricalData/hydra/issues/441)).
+- Per-package publish orchestrators `publish-maven.sh` / `publish-pypi.sh` with
+  dependency-closure and leaves-first ordering checks
+  ([#449](https://github.com/CategoricalData/hydra/issues/449)).
+- `hydra-typescript` published as a target Java/Maven + PyPI artifact
+  ([#468](https://github.com/CategoricalData/hydra/issues/468)).
+- Java coder emits a fluent builder for every generated record type
+  ([#465](https://github.com/CategoricalData/hydra/issues/465)); Python coder emits
+  per-field `with_<field>` copy-update methods and a fluent builder
+  ([#466](https://github.com/CategoricalData/hydra/issues/466)).
+
+### Improvements
+
+- Drop the vestigial `InferenceContext` parameter from the `Primitive.implementation`
+  carrier across all hosts; add a graph-free `funT` coder and six `lists` default
+  implementations ([#446](https://github.com/CategoricalData/hydra/issues/446)).
+- Derive package routing from declared modules; split derived generation into broad
+  `mainDslModules` and scoped `mainEncodingModules`
+  ([#474](https://github.com/CategoricalData/hydra/issues/474),
+  [#475](https://github.com/CategoricalData/hydra/issues/475)).
+- Hash JSON content into the per-package input digest; add `digest-check
+  refresh-input` and a CI guard that force-regenerates and diffs
+  `dist/haskell/hydra-{java,python}` ([#469](https://github.com/CategoricalData/hydra/issues/469)).
+- Per-package inference seeds downstream packages from each package's full universe
+  while inferring only write targets, fixing `hydra-scala` inference within the CI
+  heap budget; declare the `hydra-java` dependency in `hydra-scala` for cold
+  ordering ([#470](https://github.com/CategoricalData/hydra/issues/470)).
+- Remove the vestigial `Lib/Defaults` registry and empty `defaultLibModules`
+  manifest field from all hosts ([#437](https://github.com/CategoricalData/hydra/issues/437)).
+- Bundle LICENSE + NOTICE into Java jars (`META-INF`) and Python wheels
+  (`dist-info`); declare Apache-2.0 in the Scala build
+  ([#441](https://github.com/CategoricalData/hydra/issues/441)).
+- Mark lazy parameters on the Scala and Common Lisp primitive registries so eager
+  coders thunk correctly ([#453](https://github.com/CategoricalData/hydra/issues/453),
+  [#477](https://github.com/CategoricalData/hydra/issues/477),
+  [#425](https://github.com/CategoricalData/hydra/issues/425)).
+- Staging-loop WIP-commit gate to keep `WIP:` commits off `origin/main`
+  ([#466](https://github.com/CategoricalData/hydra/issues/466)).
+
+### Bug fixes
+
+- **Python wheel self-containment**: the `hydra-kernel` wheel now ships
+  `hydra.python.util`; gated by a packaging-boundary smoke test in CI and
+  `publish-pypi.sh` ([#472](https://github.com/CategoricalData/hydra/issues/472),
+  [#461](https://github.com/CategoricalData/hydra/issues/461)).
+- **Haskell sdist self-containment**: track the generated `Hydra/Dsl/Terms.hs`
+  (was gitignored) so the committed dist exports `ToPrimName`, fixing the cold
+  build of the published `hydra-kernel`
+  ([#473](https://github.com/CategoricalData/hydra/issues/473)).
+- Decode synthesizer threads the fully-applied result type into wrap/record/union
+  decoder bodies, so derived decoders emit `DataRow<v>` rather than raw `DataRow`,
+  fixing Java and Scala generic decode compilation
+  ([#476](https://github.com/CategoricalData/hydra/issues/476)).
+- Scala coder emits explicit type arguments for polymorphic non-primitive
+  references under a type application (e.g. `requireField`), fixing `Any`-inference
+  of curried decoder lambda parameters in `decode/typed`
+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).
+- Common Lisp and Emacs Lisp: move the hand-written runtime to a dialect-tier path
+  so it no longer collides with the generated `hydra.lib.*` def-modules
+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).
+- Python coder uses the binding `TypeScheme` as the authoritative source for
+  parameter and return types ([#488](https://github.com/CategoricalData/hydra/issues/488));
+  fixes a duplicate `self` parameter in builders
+  ([#478](https://github.com/CategoricalData/hydra/issues/478)).
+- Sort term definitions by name in source-file generation so non-Haskell hosts emit
+  deterministic alphabetical Haskell output (host-independent of `Maps.elems`
+  iteration order) ([#489](https://github.com/CategoricalData/hydra/issues/489)).
+- Java coder serializes the `static` method modifier (previously a non-exhaustive
+  case) ([#465](https://github.com/CategoricalData/hydra/issues/465)); JavaDoc
+  `@link`/`@param` sanitization for strict doclint
+  ([#449](https://github.com/CategoricalData/hydra/issues/449)).
+- Scala host writer appends a trailing newline when missing, fixing a Lisp-target
+  byte mismatch ([#463](https://github.com/CategoricalData/hydra/issues/463)).
+- Clojure host: silent wrapping `bigint_to_int{8,16,32,64}` casts per the kernel
+  contract ([#483](https://github.com/CategoricalData/hydra/issues/483)); load-order
+  and `--kernel-only` filter fixes after kernel renames
+  ([#425](https://github.com/CategoricalData/hydra/issues/425)); load the
+  `hydra-haskell` baseline for Clojure→Haskell rebuilds
+  ([#487](https://github.com/CategoricalData/hydra/issues/487),
+  [#460](https://github.com/CategoricalData/hydra/issues/460)).
+- Lisp-dialect bootstrap fixes: emit JSON object entries as 2-element `Pair` lists
+  rather than dotted cons ([#452](https://github.com/CategoricalData/hydra/issues/452),
+  also fixing [#16](https://github.com/CategoricalData/hydra/issues/16)); read
+  module names via the correct struct accessor
+  ([#471](https://github.com/CategoricalData/hydra/issues/471)); drop stale
+  surplus flag arguments from `generate-source-files` calls
+  ([#457](https://github.com/CategoricalData/hydra/issues/457),
+  [#458](https://github.com/CategoricalData/hydra/issues/458),
+  [#464](https://github.com/CategoricalData/hydra/issues/464)); rename eta-wrapped
+  projection/unwrap parameters to avoid kernel shadowing
+  ([#428](https://github.com/CategoricalData/hydra/issues/428)); propagate a
+  non-zero exit from the Scheme test runner on failures and fix Scheme float
+  scientific-notation formatting for `|x| >= 1e7`
+  ([#447](https://github.com/CategoricalData/hydra/issues/447)).
+- Cross-host target dispatch: Common Lisp and Clojure hosts dispatch Scala and
+  TypeScript targets ([#482](https://github.com/CategoricalData/hydra/issues/482),
+  [#483](https://github.com/CategoricalData/hydra/issues/483)); Scala/Java host
+  target-dispatch completions ([#5](https://github.com/CategoricalData/hydra/issues/5),
+  [#7](https://github.com/CategoricalData/hydra/issues/7),
+  [#17](https://github.com/CategoricalData/hydra/issues/17)).
+- TypeScript test runtime reads the kernel JSON field names `body`/`signature`
+  (not legacy `term`/`typeScheme`); `lists.nub` dedups by canonical JSON
+  ([#485](https://github.com/CategoricalData/hydra/issues/485)).
+- Sync robustness: always reassemble `dist/python` under `HYDRA_IN_SYNC` to heal
+  partial-dist state ([#480](https://github.com/CategoricalData/hydra/issues/480));
+  persist the run dir on bootstrap prep-phase failures
+  ([#481](https://github.com/CategoricalData/hydra/issues/481)); complete per-host
+  static deps so the bootstrap demo finds fresh dist
+  ([#445](https://github.com/CategoricalData/hydra/issues/445)).
+- Pin the Python target test interpreter to Python ≥ 3.12
+  ([#486](https://github.com/CategoricalData/hydra/issues/486)); Emacs Lisp / Scheme
+  target test-runner re-copy robustness
+  ([#456](https://github.com/CategoricalData/hydra/issues/456)).
+- JavaDoc Pages publish rewritten to build a combined site from the CI-generated
+  `dist/java/` artifact, fixing the failure mode where `pages.yml` ran against a
+  bare checkout with no `dist/java/` present
+  ([#450](https://github.com/CategoricalData/hydra/issues/450)).
+
+### Documentation
+
+- Document the `overlay/` self-containment model, the published-host consume model
+  for all three hosts, the `hydra.json` version / host-version basis, and a
+  migration-shims recipe ([#434](https://github.com/CategoricalData/hydra/issues/434),
+  [#370](https://github.com/CategoricalData/hydra/issues/370),
+  [#347](https://github.com/CategoricalData/hydra/issues/347)).
+- Document the kernel self-containment / `hydra.lib.*` def-module model and the
+  derived-module no-inference invariant
+  ([#473](https://github.com/CategoricalData/hydra/issues/473),
+  [#466](https://github.com/CategoricalData/hydra/issues/466)); generated Java and
+  Python record builders documented in the DSL guides
+  ([#465](https://github.com/CategoricalData/hydra/issues/465),
+  [#466](https://github.com/CategoricalData/hydra/issues/466)).
+- Use absolute GitHub URLs in package READMEs so links resolve when published
+  standalone ([#454](https://github.com/CategoricalData/hydra/issues/454)); bundle a
+  README into each Python package dir for sdist metadata
+  ([#418](https://github.com/CategoricalData/hydra/issues/418)).
+
+---
+
+## [0.16.0] - 2026-06-09
+
+Major themes: primitive-metadata reification, self-hosting coder DSLs with all
+eight hosts passing the common test suite, finalized `hydra.packaging`, and a
+deep kernel-vocabulary cleanup.
+
+### Highlights
+
+- **`PrimitiveDefinition` and per-namespace registry modules** with host-independent
+  specs for every standard-library primitive ([#156](https://github.com/CategoricalData/hydra/issues/156), [#319](https://github.com/CategoricalData/hydra/issues/319)).
+- **Self-hosting coder DSLs; all eight hosts pass the common test suite**, including
+  the completed TypeScript head ([#344](https://github.com/CategoricalData/hydra/issues/344), [#126](https://github.com/CategoricalData/hydra/issues/126)).
+- **Finalized `hydra.packaging`** and a unified `Module.dependencies` field ([#369](https://github.com/CategoricalData/hydra/issues/369), [#354](https://github.com/CategoricalData/hydra/issues/354)).
+- **Kernel-vocabulary cleanup**: `maybe`→`optional` across kernel and hosts, plus
+  order-preserving JSON objects ([#401](https://github.com/CategoricalData/hydra/issues/401), [#398](https://github.com/CategoricalData/hydra/issues/398)).
+
+### New features
+
+- Reify `PrimitiveDefinition` in `hydra.packaging` with per-namespace `hydra.lib.<sub>` registries ([#156](https://github.com/CategoricalData/hydra/issues/156)).
+- Host-independent `comments` specifications for all standard-library primitives ([#319](https://github.com/CategoricalData/hydra/issues/319)).
+- Kernel-oriented style checks in `hydra.validate.*` ([#321](https://github.com/CategoricalData/hydra/issues/321), [#351](https://github.com/CategoricalData/hydra/issues/351), [#352](https://github.com/CategoricalData/hydra/issues/352)), on a reshaped validation API ([#320](https://github.com/CategoricalData/hydra/issues/320)).
+- Promote the JSON Schema coder to a full DSL coder ([#350](https://github.com/CategoricalData/hydra/issues/350)).
+- Transpose coder sources into host-native DSLs for self-hosting ([#344](https://github.com/CategoricalData/hydra/issues/344), [#358](https://github.com/CategoricalData/hydra/issues/358)).
+- `Term`-typed annotations replacing `Map<Name, Term>` ([#386](https://github.com/CategoricalData/hydra/issues/386)).
+- Language-specific EDSL features on the kernel `Language` ([#233](https://github.com/CategoricalData/hydra/issues/233)).
+- Primitive-metadata-driven laziness in eager coders ([#391](https://github.com/CategoricalData/hydra/issues/391)).
+- `/test` skill and `bin/test.sh` for target-language test validation ([#387](https://github.com/CategoricalData/hydra/issues/387)).
+- Automatic differentiation: a `grad` transform ([#324](https://github.com/CategoricalData/hydra/issues/324)).
+- `hydra.show.error.pg` for `InvalidGraphError` ([#374](https://github.com/CategoricalData/hydra/issues/374)).
+
+### Improvements
+
+- Finalize `hydra.packaging`: `Binding`→`TypeDefinition`, `Module`/`Package` `comments`, `moduleName` cleanup ([#369](https://github.com/CategoricalData/hydra/issues/369), [#396](https://github.com/CategoricalData/hydra/issues/396), [#402](https://github.com/CategoricalData/hydra/issues/402), [#404](https://github.com/CategoricalData/hydra/issues/404)).
+- Merge `Module.termDependencies`/`typeDependencies` into one `dependencies` field ([#354](https://github.com/CategoricalData/hydra/issues/354)).
+- Resolve the `maybe`/`optional` ambiguity across kernel and all hosts ([#401](https://github.com/CategoricalData/hydra/issues/401)).
+- Order-preserving JSON objects; order-sensitive `Value` equality ([#398](https://github.com/CategoricalData/hydra/issues/398)).
+- Rename `Namespace`→`ModuleName` ([#316](https://github.com/CategoricalData/hydra/issues/316)) and the phantom DSL types to `Typed*` ([#397](https://github.com/CategoricalData/hydra/issues/397)).
+- Move from a type-class enum to type-class names ([#275](https://github.com/CategoricalData/hydra/issues/275)).
+- Repackage "eval lib" modules as kernel lib modules; promote remaining sources ([#260](https://github.com/CategoricalData/hydra/issues/260), [#355](https://github.com/CategoricalData/hydra/issues/355), [#356](https://github.com/CategoricalData/hydra/issues/356)).
+- Reshape `hydra.context` into `InferenceContext` ([#368](https://github.com/CategoricalData/hydra/issues/368)).
+- Streamline the Haskell, Java, Python, and Scala syntax models, re-pinning Java to SE 21 and Python to the 3.14 PEG grammar ([#297](https://github.com/CategoricalData/hydra/issues/297)).
+- Adopt persistent immutable collections across hosts ([#359](https://github.com/CategoricalData/hydra/issues/359), [#360](https://github.com/CategoricalData/hydra/issues/360), [#361](https://github.com/CategoricalData/hydra/issues/361), [#362](https://github.com/CategoricalData/hydra/issues/362)).
+- Migrate underscored kernel definition names to camelCase ([#348](https://github.com/CategoricalData/hydra/issues/348)).
+- Tidy qualified/unqualified imports in the Haskell DSL sources ([#308](https://github.com/CategoricalData/hydra/issues/308)).
+- Eliminate the `Hydra.Module.Compat` shim ([#315](https://github.com/CategoricalData/hydra/issues/315)).
+- Homogenize writer conventions across target languages ([#339](https://github.com/CategoricalData/hydra/issues/339)).
+- Disambiguate format-version field naming across JSON metadata ([#412](https://github.com/CategoricalData/hydra/issues/412)).
+- Per-package DSL→JSON build with per-package incremental inference ([#381](https://github.com/CategoricalData/hydra/issues/381), [#395](https://github.com/CategoricalData/hydra/issues/395)).
+- Prune stale `dist/` outputs; self-heal digests; exclude digests from VCS; reconcile drift; fail loud ([#357](https://github.com/CategoricalData/hydra/issues/357), [#393](https://github.com/CategoricalData/hydra/issues/393), [#405](https://github.com/CategoricalData/hydra/issues/405), [#378](https://github.com/CategoricalData/hydra/issues/378), [#379](https://github.com/CategoricalData/hydra/issues/379), [#392](https://github.com/CategoricalData/hydra/issues/392), [#414](https://github.com/CategoricalData/hydra/issues/414)).
+- Accept all valid (host, target) pairs in the generation drivers ([#421](https://github.com/CategoricalData/hydra/issues/421)).
+- Move Gradle build infrastructure into `heads/java/`; remove top-level `pixi.toml` ([#384](https://github.com/CategoricalData/hydra/issues/384), [#385](https://github.com/CategoricalData/hydra/issues/385)).
+- Eliminate post-generation test patches; fix loader/runner kludges; re-enable test timing ([#307](https://github.com/CategoricalData/hydra/issues/307), [#309](https://github.com/CategoricalData/hydra/issues/309), [#311](https://github.com/CategoricalData/hydra/issues/311)).
+- Performance/benchmarks and usability assessments ([#277](https://github.com/CategoricalData/hydra/issues/277), [#283](https://github.com/CategoricalData/hydra/issues/283)).
+- Split the Hackage distribution into per-package distributions ([#418](https://github.com/CategoricalData/hydra/issues/418)).
+
+### Bug fixes
+
+- Encode `uint32` JSON literals as numbers, not strings ([#431](https://github.com/CategoricalData/hydra/issues/431)).
+- Satisfy or suppress warnings in generated Java ([#349](https://github.com/CategoricalData/hydra/issues/349)).
+- Restore JSON parser test cases (polymorphic case handling, ordering fallback) ([#336](https://github.com/CategoricalData/hydra/issues/336)).
+- Keep annotations through `termAlternatives`/`typeAlternatives` adaptation ([#353](https://github.com/CategoricalData/hydra/issues/353)).
+- Scala host decodes module JSON containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).
+- Java coder: fix exponential `let`-bound `cases` cost ([#372](https://github.com/CategoricalData/hydra/issues/372)) and explicit type args on `PersistentMap.ofEntries` ([#394](https://github.com/CategoricalData/hydra/issues/394)).
+- Python-host codegen: drop extra `pyStringToPyStrings` wrapping ([#367](https://github.com/CategoricalData/hydra/issues/367)).
+- `escape_literal_char` no longer mangles RDF triples ([#363](https://github.com/CategoricalData/hydra/issues/363)).
+- Sync robustness: stale coder JSON, omitted native modules, dead helper, bad source dirs ([#406](https://github.com/CategoricalData/hydra/issues/406), [#400](https://github.com/CategoricalData/hydra/issues/400), [#411](https://github.com/CategoricalData/hydra/issues/411), [#408](https://github.com/CategoricalData/hydra/issues/408)).
+- Cross-host self-hosting fixes (Scala, TypeScript, and the four Lisp dialects) ([#422](https://github.com/CategoricalData/hydra/issues/422), [#423](https://github.com/CategoricalData/hydra/issues/423), [#424](https://github.com/CategoricalData/hydra/issues/424), [#429](https://github.com/CategoricalData/hydra/issues/429), [#444](https://github.com/CategoricalData/hydra/issues/444), [#366](https://github.com/CategoricalData/hydra/issues/366), [#389](https://github.com/CategoricalData/hydra/issues/389), [#407](https://github.com/CategoricalData/hydra/issues/407), [#425](https://github.com/CategoricalData/hydra/issues/425), [#426](https://github.com/CategoricalData/hydra/issues/426), [#427](https://github.com/CategoricalData/hydra/issues/427), [#432](https://github.com/CategoricalData/hydra/issues/432), [#438](https://github.com/CategoricalData/hydra/issues/438), [#439](https://github.com/CategoricalData/hydra/issues/439), [#443](https://github.com/CategoricalData/hydra/issues/443)).
+
+### Removed
+
+- Removed the `bigfloat` literal type from `FloatType` and `FloatValue` ([#330](https://github.com/CategoricalData/hydra/issues/330)).
+  Arbitrary-precision floating-point values were inconsistently supported
+  across host languages (Java/Scala in particular lacked a true IEEE 754
+  arbitrary-precision implementation), and nothing in the codebase relied on
+  them. `FloatType` and `FloatValue` now have only `float32` and `float64`
+  variants. Removed library primitives: `bigfloatToBigint`, `bigfloatToFloat32`,
+  `bigfloatToFloat64`, `bigintToBigfloat`, `float32ToBigfloat`,
+  `float64ToBigfloat`, `readBigfloat`, `showBigfloat`, `roundBigfloat`. New
+  primitives `float32ToFloat64` and `float64ToFloat32` (the latter lossy)
+  replace the removed bigfloat-routed conversions.
+- Removed `heads/haskell/bin/assemble-hackage-sdist.sh` ([#418](https://github.com/CategoricalData/hydra/issues/418)), the 0.15-era
+  bridge that flattened the multi-source-dir Haskell head into one self-contained
+  `hydra` sdist. Superseded by the per-package assembler (see Improvements).
+
+### Documentation
+
+- Comprehensive documentation refresh for 0.16 ([#383](https://github.com/CategoricalData/hydra/issues/383))
+  spanning nine tracks across READMEs, `docs/`, the wiki, CLAUDE.md, and
+  in-source kernel comments.
+- New `docs/json-format.md` reference describing the canonical JSON wire format
+  (tagged-union duality, optional-field rules, IEEE 754 sentinels, integer
+  threshold).
+- New wiki pages: `Design` (rationale behind each major choice) and `Inference`
+  (HM type inference with class constraints).
+- Cross-checked every prose doc against current code; corrected drift in
+  primitive-checking sections of `docs/recipes/maintenance.md`, the `Primitive`
+  shape in `docs/implementation.md` and `docs/recipes/adding-primitives.md`,
+  and the build-system narrative.
+- Wove motivation ("the why") through the existing doc surface rather than
+  collecting it into separately-titled sidebars; landed an inference-overview
+  centerpiece on the wiki ([#377](https://github.com/CategoricalData/hydra/issues/377)).
+- Aligned doc vocabulary with the LambdaGraph paper and the literature review
+  for the design space Hydra inhabits.
+- Net-new READMEs for `packages/hydra-kernel`, `packages/hydra-ext`,
+  `packages/hydra-coq`, and `packages/hydra-wasm`; top-level `README.md`
+  now carries a canonical packages table.
+- Audited and refreshed the Claude surface: CLAUDE.md "Where to look up X"
+  table extended with rows for `docs/getting-started.md`, `docs/json-format.md`,
+  and the `Design` / `Inference` wiki pages; hard-rules block reordered by
+  violation frequency; `claude/pitfalls.md` superseded entries folded into
+  `docs/troubleshooting.md` / recipes.
+- Project-descriptor strings reviewed and aligned across 24 build / packaging
+  files (Hackage synopsis, Maven Central description, PyPI / conda-forge
+  classifiers, Hydra-format `package.json` files).
+- `docs/index.html` (the GitHub Pages landing page) refreshed with audience
+  hops into wiki Concepts / Design, `docs/getting-started.md`, and the GitHub
+  repo, plus the full published-artifact list across Hackage, Maven Central,
+  PyPI, and conda-forge.
+- In-source kernel-code rationale comments added at key Sources sites covering
+  injection / pair / either / unit-void duality, error taxonomy, variant
+  records, inference-context threading, validation profiles, reduction state,
+  lexical filters, name mangling, scoping, variable handling, defaults
+  integration, and Tarjan SCC choice rationale. JSON encode/decode modules
+  cross-reference `docs/json-format.md`.
+- Filed `Primitive.implementation` carrier-simplification follow-up
+  ([#446](https://github.com/CategoricalData/hydra/issues/446))
+  to drop the unused `InferenceContext` and `Graph` parameters once the
+  `Lib/Defaults/` integration ([#437](https://github.com/CategoricalData/hydra/issues/437))
+  lands.
+
+---
+
+## [0.15.0] - 2026-04-29
+
+A structural-cleanup release.
+The repository is reorganized into a three-tree
+`packages/` (DSL sources) / `heads/` (per-host runtime) / `dist/` (generated output)
+layout ([#290](https://github.com/CategoricalData/hydra/issues/290)), the kernel is simplified ([#251](https://github.com/CategoricalData/hydra/issues/251), [#292](https://github.com/CategoricalData/hydra/issues/292), [#332](https://github.com/CategoricalData/hydra/issues/332)), and Java + Python now
+ship as per-package publishable artifacts on Maven Central / PyPI / conda-forge
+([#305](https://github.com/CategoricalData/hydra/issues/305)).
+Incremental, content-hash-based caches accelerate the sync pipeline ([#247](https://github.com/CategoricalData/hydra/issues/247)).
+Three new generation-only targets — Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)), and an
+automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)) — are in progress as Claude collaborations.
+
+### Highlights
+
+- **Three-tree repository layout**: `packages/` (DSL), `heads/` (host runtime),
+  `dist/` (generated) ([#290](https://github.com/CategoricalData/hydra/issues/290)).
+- **Per-package distributions** for Java (4 Maven artifacts) and Python (5 wheels):
+  `hydra-kernel`, `hydra-pg`, `hydra-rdf`, `hydra-{java,python}`, plus `hydra-ext`
+  on PyPI ([#305](https://github.com/CategoricalData/hydra/issues/305)).
+- **Kernel simplifications**: `Function`/`Elimination` removed ([#332](https://github.com/CategoricalData/hydra/issues/332)),
+  `FunctionPrimitive` removed ([#251](https://github.com/CategoricalData/hydra/issues/251)), `Hydra.Ext.*` prefix retired ([#331](https://github.com/CategoricalData/hydra/issues/331)),
+  `Context` error wrapper gone ([#292](https://github.com/CategoricalData/hydra/issues/292)).
+- **Incremental caches** across the sync pipeline; ~70x speedup on no-op resync ([#247](https://github.com/CategoricalData/hydra/issues/247)).
+- **JSON kernel format v1** with formal wire-format spec and four-field rename ([#343](https://github.com/CategoricalData/hydra/issues/343)).
+- **Three new generation-only targets** (in progress): Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)),
+  automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)).
+
+### New features
+
+- Per-package distributions ([#305](https://github.com/CategoricalData/hydra/issues/305)): standalone Maven / PyPI / conda-forge builds,
+  generated `build.gradle` / `pyproject.toml` per package, transitive dep resolution.
+- JSON kernel format v1 ([#343](https://github.com/CategoricalData/hydra/issues/343)): formal spec at `docs/json-format.md`,
+  four-field rename to `typeScheme`, `Module` field reorder, `formatVersion` stamp.
+- `decimal` literal type in the kernel ([#338](https://github.com/CategoricalData/hydra/issues/338)) across all hosts.
+- Type-directed JSON encoder with idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314), [#318](https://github.com/CategoricalData/hydra/issues/318)).
+- Incremental type inference plus content-hash caches ([#247](https://github.com/CategoricalData/hydra/issues/247)).
+- Coq generation target ([#326](https://github.com/CategoricalData/hydra/issues/326), in progress): `hydra-coq` package, 131/131 `.v` files pass `coqc`.
+- WebAssembly target ([#325](https://github.com/CategoricalData/hydra/issues/325), in progress): `hydra-wasm` package, M4 closure mechanism.
+- Automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324), in progress): symbolic source-to-source.
+- `hydra.show.error` module ([#265](https://github.com/CategoricalData/hydra/issues/265)): consolidated error-message builders.
+- `hydra.lib.maybes.toList` primitive ([#257](https://github.com/CategoricalData/hydra/issues/257)).
+- NaN / Inf round-tripping through JSON and per-language serdes ([#312](https://github.com/CategoricalData/hydra/issues/312), [#318](https://github.com/CategoricalData/hydra/issues/318), [#330](https://github.com/CategoricalData/hydra/issues/330)).
+- Typeclass inference test group ([#274](https://github.com/CategoricalData/hydra/issues/274)).
+- Term and type linters ([#232](https://github.com/CategoricalData/hydra/issues/232)).
+- Validation for modules and graphs ([#155](https://github.com/CategoricalData/hydra/issues/155)).
+- User-defined-function (UDF) support and DSL-vs-primitive overrides
+  ([#62](https://github.com/CategoricalData/hydra/issues/62), [#63](https://github.com/CategoricalData/hydra/issues/63), [#102](https://github.com/CategoricalData/hydra/issues/102), [#158](https://github.com/CategoricalData/hydra/issues/158)).
+- Stale-source detection across sync entrypoints ([#228](https://github.com/CategoricalData/hydra/issues/228)).
+
+### Improvements
+
+- Sync infrastructure: matrix tool, per-package orchestrator, per-language wrappers ([#290](https://github.com/CategoricalData/hydra/issues/290)).
+- TestGraph post-generation patches eliminated; DSL emits `TestEnv` refs directly.
+- Minimized standard imports in generated Haskell ([#161](https://github.com/CategoricalData/hydra/issues/161)); improved auto-aliases ([#322](https://github.com/CategoricalData/hydra/issues/322)).
+- Removed kernel term dependencies from the interpreter ([#257](https://github.com/CategoricalData/hydra/issues/257)).
+- Removed `Graph` and `Context` arguments from primitive implementations ([#266](https://github.com/CategoricalData/hydra/issues/266)).
+- Refactored kernel term modules: split rewriting/schemas, renamed show.meta → codegen,
+  moved `Coder` to `coders`, merged `extract.helpers` ([#221](https://github.com/CategoricalData/hydra/issues/221)).
+- Removed Aeson and HsYAML dependencies; YAML coder moved to `hydra-ext` ([#261](https://github.com/CategoricalData/hydra/issues/261)).
+- Lisp recursive let bindings via SCC ([#341](https://github.com/CategoricalData/hydra/issues/341)); parenthesis cleanup ([#84](https://github.com/CategoricalData/hydra/issues/84)).
+- Everything-to-everything bootstrapping demo ([#254](https://github.com/CategoricalData/hydra/issues/254)).
+- Re-enabled skipped Python tests; `disabledForPython` retired ([#263](https://github.com/CategoricalData/hydra/issues/263)).
+- Promoted host-specific code in `packages/` into per-head locations ([#337](https://github.com/CategoricalData/hydra/issues/337)).
+- Migrated `hydra.common` Java module out ([#10](https://github.com/CategoricalData/hydra/issues/10)).
+- Test infrastructure unification under `UniversalTestCase` ([#246](https://github.com/CategoricalData/hydra/issues/246)).
+- Default property graph → RDF mapping ([#296](https://github.com/CategoricalData/hydra/issues/296)).
+- 13 unsafe partial primitives replaced with `Maybe`-returning alternatives ([#201](https://github.com/CategoricalData/hydra/issues/201)).
+- Java generated code uses standard `java.util` collection interfaces ([#313](https://github.com/CategoricalData/hydra/issues/313)).
+- `Term.union` renamed to `Term.inject` ([#334](https://github.com/CategoricalData/hydra/issues/334)).
+- Inconsistencies in domain DSLs cleaned up ([#219](https://github.com/CategoricalData/hydra/issues/219)).
+- Coder packages moved out of hydra-haskell ([#182](https://github.com/CategoricalData/hydra/issues/182)).
+- Java package-naming scheme revised ([#223](https://github.com/CategoricalData/hydra/issues/223)).
+- Decimal used (instead of bigfloat) for JSON numbers ([#340](https://github.com/CategoricalData/hydra/issues/340)).
+- Hydra kernel moved out of hydra-haskell ([#282](https://github.com/CategoricalData/hydra/issues/282)).
+
+### Bug fixes
+
+- `substInTypeScheme` capture-unsafe substitution under nested forall binders.
+- Java `Float64` arithmetic primitives corrected for current `PrimitiveFunction` API.
+- Clojure decimal handling: value-based equality, `BigInteger` return from `decimal_to_bigint`.
+- Scheme runtime R7RS imports for `sets.scm` / `maps.scm` / `eithers.map_set`.
+- Python coder defaults corrected from `Py.Name` to `Py.Expression`.
+- Scala host JSON-decode failure on modules containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).
+- Lisp coder mutually-recursive let bindings for Clojure ([#341](https://github.com/CategoricalData/hydra/issues/341)).
+
+### Documentation
+
+- Documentation refresh for the 0.15 packaging restructure ([#290](https://github.com/CategoricalData/hydra/issues/290), [#331](https://github.com/CategoricalData/hydra/issues/331)); CLAUDE.md,
+  READMEs, recipes, demos, and seven wiki pages updated.
+- Code-generation recipe rewritten for the per-package dist layout ([#282](https://github.com/CategoricalData/hydra/issues/282)).
+- New `maintenance.md` recipe consolidates non-source-file scans, stale generated
+  detection, design-violation checks, and freshness checks.
+- Documentation style guide added at `docs/documentation-style-guide.md`.
+- Cross-worktree messaging protocol documented in CLAUDE.md.
+- Decimal type documented in the lexicon and per-language READMEs ([#338](https://github.com/CategoricalData/hydra/issues/338)).
+- JSON encoding format docs updated for idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314)).
+
+---
+
+## [0.14.1] - 2026-03-30
+
+Patch release.
+Regenerates all implementations after a fix to the group eval primitive ([#281](https://github.com/CategoricalData/hydra/issues/281)),
+and relocates the property-graph and RDF/SHACL "ext" modules into hydra-java and hydra-python.
+
+### Improvements
+
+- Moved PG, RDF, and SHACL ext modules from hydra-ext into hydra-java and hydra-python.
+
+### Bug fixes
+
+- Group eval primitive fix; all targets regenerated ([#281](https://github.com/CategoricalData/hydra/issues/281)).
+- JavaDoc HTML-entity escaping in generated `DestructuringPattern.java`.
+
+---
+
+## [0.14.0] - 2026-03-29
+
+Major release adding four new complete Hydra implementations — Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)),
+Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, and Scheme — bringing the total to seven bootstrapping hosts
+(plus Emacs Lisp, which passes the test suite but does not yet participate in bootstrapping).
+Also includes kernel simplifications, an Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)),
+eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)), new demos, and significant performance work on the Scheme host.
+
+### Highlights
+
+- **Four new complete implementations**: Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)), Hydra-Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)),
+  Hydra-Common Lisp, and Hydra-Scheme pass the common test suite and can serve as
+  bootstrapping hosts.
+  The four Lisp dialects share a single coder and serializer.
+- **Kernel simplifications**: removed `RowType`/`WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)),
+  unified `Graph`/`TypeContext`/`InferenceContext` ([#192](https://github.com/CategoricalData/hydra/issues/192)),
+  replaced `Module.elements` with `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)),
+  consolidated error types ([#268](https://github.com/CategoricalData/hydra/issues/268)), and promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).
+- **Avro bidirectional coder** ([#301](https://github.com/CategoricalData/hydra/issues/301)) with property graph pipeline demo.
+- **Scheme bootstrap performance**: 58 minutes → 5.7 minutes via O(1) vhash data structures
+  and IEEE 754 float precision fixes.
+
+### Breaking changes
+
+- Removed legacy adapter framework; replaced by the staging-promoted variant ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).
+- Replaced legacy Flow monad with Either ([#245](https://github.com/CategoricalData/hydra/issues/245)).
+- Removed `Module.elements`; use `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)).
+- Removed `RowType` and `WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)).
+- Renamed `hydra.accessors` to `hydra.paths` ([#271](https://github.com/CategoricalData/hydra/issues/271)).
+- Renamed `hydra.tarjan` and merged into `hydra.sorting` ([#220](https://github.com/CategoricalData/hydra/issues/220)).
+- Merged `hydra.constraints` into `hydra.query` ([#272](https://github.com/CategoricalData/hydra/issues/272)).
+- Moved `hydra.workflow` to hydra-ext ([#270](https://github.com/CategoricalData/hydra/issues/270)).
+- Consolidated `hydra.compute` into `hydra.util` ([#269](https://github.com/CategoricalData/hydra/issues/269)).
+- Removed `hydra.describe` ([#216](https://github.com/CategoricalData/hydra/issues/216)) and types from `hydra.mantle` ([#217](https://github.com/CategoricalData/hydra/issues/217)).
+- Replaced `OtherError` with task-specific error types ([#268](https://github.com/CategoricalData/hydra/issues/268)).
+- Java: lowered minimum Java version to 11 ([#249](https://github.com/CategoricalData/hydra/issues/249)).
+- Java: `Pair` replaces `Tuple2` ([#252](https://github.com/CategoricalData/hydra/issues/252)); `Comparable` implemented for generated classes ([#131](https://github.com/CategoricalData/hydra/issues/131)).
+
+### New features
+
+- Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)): complete implementation, sbt/Scala 3, 3043 tests.
+- Hydra-Lisp: Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, Emacs Lisp, Scheme — four dialects,
+  one coder. CI workflows for Clojure, Common Lisp, and Scheme.
+- Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)) with demo.
+- Eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)): Logic, Equality, Math, collections, and Groups.
+- Generated DSL modules ([#180](https://github.com/CategoricalData/hydra/issues/180)): `hydra.dsls` generates DSL helpers from type modules.
+- New demos: GraphQL+JSON ([#279](https://github.com/CategoricalData/hydra/issues/279)), PG validation ([#284](https://github.com/CategoricalData/hydra/issues/284)), SHACL ([#294](https://github.com/CategoricalData/hydra/issues/294)), Avro+PG.
+- Packaging module ([#290](https://github.com/CategoricalData/hydra/issues/290)): `hydra.packaging` with `Package` type and validation.
+- New primitives: `lists.foldr` ([#280](https://github.com/CategoricalData/hydra/issues/280)), `maybes.toList`, float rounding ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).
+- Cross-language benchmarking suite ([#234](https://github.com/CategoricalData/hydra/issues/234)).
+- Limited typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)).
+- Standardized validation patterns across modules ([#291](https://github.com/CategoricalData/hydra/issues/291)).
+
+### Improvements
+
+- Promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).
+- Removed legacy adapters, JSON/YAML coders, grammar framework ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).
+- Java: efficient immutable data structures ([#193](https://github.com/CategoricalData/hydra/issues/193)); flattened term naming.
+- Java: hidden specialized collection classes in type-level files ([#313](https://github.com/CategoricalData/hydra/issues/313)).
+- Inference error messages improved ([#231](https://github.com/CategoricalData/hydra/issues/231)).
+- Combined nested let bindings in the Haskell coder ([#248](https://github.com/CategoricalData/hydra/issues/248)).
+- Simplified `hydra.adapt.simple` ([#255](https://github.com/CategoricalData/hydra/issues/255)).
+- Removed Haskell operators dependency from tests ([#288](https://github.com/CategoricalData/hydra/issues/288)).
+- Regression tests for non-Haskell/Java coders ([#85](https://github.com/CategoricalData/hydra/issues/85)).
+- Regex support added ([#293](https://github.com/CategoricalData/hydra/issues/293)).
+- `hydra.annotations.isNativeType` revisited ([#214](https://github.com/CategoricalData/hydra/issues/214)).
+- Migrated grammar-generated models ([#295](https://github.com/CategoricalData/hydra/issues/295)).
+- `<<= -shouldBe-> <<~` operator change ([#276](https://github.com/CategoricalData/hydra/issues/276)).
+- Minimize Generation.hs ([#225](https://github.com/CategoricalData/hydra/issues/225)).
+- Implemented missing Flows primitives ([#183](https://github.com/CategoricalData/hydra/issues/183)).
+- Removed JavaDocs from the repository ([#262](https://github.com/CategoricalData/hydra/issues/262)).
+- Floating-point test portability fixes for Linux CI ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).
+- Moved YAML coder to hydra-ext ([#224](https://github.com/CategoricalData/hydra/issues/224)).
+- Minimized native Python and Java primitives in favor of DSL implementations ([#244](https://github.com/CategoricalData/hydra/issues/244)).
+- Removed the `disabledForPython` test tag ([#250](https://github.com/CategoricalData/hydra/issues/250)).
+
+### Release tooling
+
+- 0.14 release tracking ([#304](https://github.com/CategoricalData/hydra/issues/304)).
+
+### Documentation
+
+- Thorough cleanup of user documentation ([#302](https://github.com/CategoricalData/hydra/issues/302), [#303](https://github.com/CategoricalData/hydra/issues/303)).
+- Coding style guide added to wiki.
+- Updated 'new implementation' recipe with learnings from Clojure head ([#278](https://github.com/CategoricalData/hydra/issues/278)).
+
+---
+
+## [0.13.0] - 2026-02-27
+
+Major release completing Hydra-Python ([#66](https://github.com/CategoricalData/hydra/issues/66)) and Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)) as self-hosting Hydra implementations
+and demonstrating mutual self-hosting across all three languages.
+Significant improvements to type inference, type checking, rewriting, and adaptation.
+New language features include first-class Either types, typeclass inference, binary data support,
+and a native JSON parser/writer.
+Comprehensive tooling for cross-implementation bootstrapping
+and provisional support for Go, Rust, and JavaScript targets.
+
+### Highlights
+
+- **Mutual self-hosting across three implementations**: Hydra is now fully self-hosting
+  in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)), Java, and Python, and can cross-generate between every combination
+  of host and target language (9 paths total).
+- **Hydra-Java is complete** ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass.
+- **Hydra-Python is complete** ([#66](https://github.com/CategoricalData/hydra/issues/66)): 100% test parity with Haskell.
+- **Language coders promoted into the Hydra kernel** ([#176](https://github.com/CategoricalData/hydra/issues/176)): Haskell, Java, and Python
+  coders are now defined as Hydra DSL modules, making them self-hosting.
+- **Either type support** ([#210](https://github.com/CategoricalData/hydra/issues/210)) with full inference, checking, and library support.
+- **Native JSON parser and writer** ([#188](https://github.com/CategoricalData/hydra/issues/188), [#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)): Hydra's own JSON parser and writer
+  replace the Aeson dependency; bootstrap-from-JSON architecture for cross-implementation
+  code generation.
+
+### Breaking changes
+
+- Renamed `Optional` to `Maybe` throughout the codebase ([#204](https://github.com/CategoricalData/hydra/issues/204)):
+  `hydra.lib.optionals` → `hydra.lib.maybes`; all `optional` variants renamed to `maybe`.
+- Removed unlabeled product and sum types; replaced with pair types ([#212](https://github.com/CategoricalData/hydra/issues/212)).
+- Renamed `hydra.core.TypedTerm` to `hydra.core.TypeApplicationTerm`.
+- Renamed `hydra.json` to `hydra.json.model`.
+- Renamed `hydra.lib.maps.remove` to `hydra.lib.maps.delete`.
+- Removed deprecated `hydra.decoding` module.
+- Removed old `hydra.mantle.Either` type (replaced by core `Either`).
+- Removed `hydra.lib.tuples` library.
+- Removed C# coder stub (C# syntax model remains).
+- DSL syntax migration: removed `OverloadedStrings` for term expressions ([#238](https://github.com/CategoricalData/hydra/issues/238)).
+- Removed `Hydra.Dsl.ShorthandTypes` ([#222](https://github.com/CategoricalData/hydra/issues/222)).
+
+### New features
+
+- Self-hosting in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)) and full mutual cross-generation (Haskell ↔ Java ↔ Python).
+- New bootstrapping demo validating all 9 paths across 249 modules.
+- Promoted Haskell, Java, and Python coders from staging code into Hydra DSL sources ([#176](https://github.com/CategoricalData/hydra/issues/176)).
+- JSON-as-source-of-truth bootstrapping architecture ([#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)):
+  new executables and scripts enabling `bootstrap-from-json` for cross-implementation
+  code generation.
+- Generated term encoders and decoders replace legacy hand-coded modules ([#47](https://github.com/CategoricalData/hydra/issues/47)).
+- Hydra-Python completion ([#66](https://github.com/CategoricalData/hydra/issues/66)): restructured project layout with `src/main` and
+  `src/gen-main` ([#191](https://github.com/CategoricalData/hydra/issues/191)); full library implementations including `hydra.lib.flows`;
+  `@lru_cache` optimization for nullary bindings; PyPy compatibility.
+- Hydra-Java completion ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass; deep changes
+  to Java coder; `Lazy` utility class for delayed evaluation; array-type support
+  in Java serde; tail-call optimization in the Java coder; `Tuple` implements `Comparable`.
+- Either type ([#210](https://github.com/CategoricalData/hydra/issues/210)): `EitherType`, `either` term constructor, `hydra.lib.eithers` library
+  with `either`, `map`, `mapList`, `mapMaybe`, `bimap`, `bind`, `fromLeft`, `fromRight`,
+  `isLeft`, `isRight`, `lefts`, `rights`, `partitionEithers`.
+- Pair type as a core construct ([#211](https://github.com/CategoricalData/hydra/issues/211)).
+- Void type ([#237](https://github.com/CategoricalData/hydra/issues/237)): uninhabited `void` type as the dual of `unit`; type-level only.
+- Native JSON parser and writer ([#188](https://github.com/CategoricalData/hydra/issues/188), [#242](https://github.com/CategoricalData/hydra/issues/242)):
+  bidirectional JSON encoder/decoder; replaces the Aeson dependency;
+  cross-checked via a special test runner.
+- Typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)):
+  type schemes with typeclass constraints via `TypeVariableMetadata`;
+  typeclass metadata on primitive definitions; Haskell coder uses typeclass info.
+- Binary/`ByteString` support ([#172](https://github.com/CategoricalData/hydra/issues/172)): binary data via `ByteString` instead of `String`;
+  Haskell coder uses `Data.ByteString`; new `binaryToBytes` primitive.
+- Parser combinators: new `hydra.parsing` module with combinator types and DSL.
+- Higher-order primitive interpreter ([#198](https://github.com/CategoricalData/hydra/issues/198)): all primitives are fully interpretable
+  across all three implementations; legacy `requiresInterp` tag removed.
+- Let hoisting and flattening: hoisting polymorphic let terms;
+  refined hoisting for monomorphic bindings inside polymorphic ones;
+  more efficient `liftLambdaAboveLet` ([#202](https://github.com/CategoricalData/hydra/issues/202));
+  case-statement hoisting ([#241](https://github.com/CategoricalData/hydra/issues/241)); subterm hoisting helpers.
+- Provisional language targets: Go ([#65](https://github.com/CategoricalData/hydra/issues/65)), Rust (with experimental type-level coder),
+  JavaScript (syntax model, serde, DSL, generated sources), and Java/Python syntax DSLs.
+- New adapter framework ([#236](https://github.com/CategoricalData/hydra/issues/236)): all external coders refactored
+  (Haskell, YAML, Scala, JSON Schema, C++, PDL, Protobuf, GraphQL).
+- Compact labeled records and variants ([#122](https://github.com/CategoricalData/hydra/issues/122)).
+- New primitives:
+  `hydra.lib.lists.find`, `hydra.lib.lists.partition`,
+  `hydra.lib.flows.withDefault`, `hydra.lib.flows.foldl`,
+  `hydra.lib.math.{max,min,abs,pred,signum,succ,even,odd}`,
+  `hydra.lib.pairs.bimap`, `hydra.lib.eithers.bind`,
+  `hydra.lib.literals.binaryToBytes`, complete `readXxx`/`showXxx` families,
+  `hydra.lexical.chooseUniqueName`, `neg` renamed to `negate`,
+  full floating-point math primitives in Python ([#208](https://github.com/CategoricalData/hydra/issues/208)).
+- DeepCore DSL: a layer one level deeper than the Meta DSLs,
+  for programs that construct programs that construct terms.
+- `typeOf` implementation ([#168](https://github.com/CategoricalData/hydra/issues/168)).
+- Implement `Comparable` for generated Java classes ([#131](https://github.com/CategoricalData/hydra/issues/131)); update of Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)).
+- Compact labeled records exploration ([#122](https://github.com/CategoricalData/hydra/issues/122)).
+- Comparison primitives without typeclasses ([#187](https://github.com/CategoricalData/hydra/issues/187)).
+- Investigated core support for Either and Flow monads ([#200](https://github.com/CategoricalData/hydra/issues/200)).
+
+### Improvements
+
+- Type system:
+  - Refactored `hydra.inference` to create new module `hydra.checking`.
+  - Inference checks after unification to prevent schema names from being unified
+    with inferred type variables.
+  - Type application terms preserved when preparing application terms for Python.
+  - Sanity-check tuple projection index against arity during inference.
+  - Bind lost type variables in term annotations.
+  - Made `extendTypeContextForLet` tolerant of untyped bindings.
+- Code generation:
+  - Python: support for deeply-nested match statements; more complete `let` support;
+    Pythonic syntax for polymorphic function definitions; refinements for complex
+    case-hoisting scenarios; performance improvements ([#209](https://github.com/CategoricalData/hydra/issues/209), [#239](https://github.com/CategoricalData/hydra/issues/239), [#240](https://github.com/CategoricalData/hydra/issues/240)); inline
+    let/case rewriting for Python targets ([#203](https://github.com/CategoricalData/hydra/issues/203)).
+  - Java: method declaration style consistent with calling style.
+  - Haskell: standardized typeclass names.
+  - Increased maximum trace depth to support more complex sources.
+- Common test suite promotion: all tests promoted into a shared, implementation-independent
+  test kernel ([#213](https://github.com/CategoricalData/hydra/issues/213)).
+- Statically-compiled test suite in Haskell ([#207](https://github.com/CategoricalData/hydra/issues/207)).
+- Included all Hydra kernel types in test schema ([#205](https://github.com/CategoricalData/hydra/issues/205)).
+- Reorganized Haskell DSL definitions; standardized imports.
+- Added TODO comments to all unsafe primitives ([#201](https://github.com/CategoricalData/hydra/issues/201)).
+- New `rewriteAndFoldTerm` utility for simultaneous rewriting and folding.
+- Lexical helper for dereferencing schema types through aliases.
+- Made JSON parser lazy with new `lazy` parser combinator.
+- More efficient substitution helpers for empty substitutions.
+- Precomputed type/inference context in kernel test runner for performance.
+- Property graph encoding and decoding modules promoted into DSL.
+- `hydra.tabular` and `hydra.pg.graphson` modules promoted into DSL.
+- `hydra.show.*` modules generated into Java and Python.
+- Aligned epsilon encoding with the LambdaGraph spec ([#89](https://github.com/CategoricalData/hydra/issues/89)).
+- Fixed asymmetry of introductions and eliminations ([#86](https://github.com/CategoricalData/hydra/issues/86), [#134](https://github.com/CategoricalData/hydra/issues/134)).
+- Minimized inferred type annotations ([#114](https://github.com/CategoricalData/hydra/issues/114)).
+- Investigated combining products with records, sums with unions ([#196](https://github.com/CategoricalData/hydra/issues/196), [#212](https://github.com/CategoricalData/hydra/issues/212)).
+- Refined type reduction in adapters ([#144](https://github.com/CategoricalData/hydra/issues/144)).
+- Investigation of unification issues ([#163](https://github.com/CategoricalData/hydra/issues/163)).
+- Refactored RowType ([#82](https://github.com/CategoricalData/hydra/issues/82)).
+- LLM-assisted PG schemas and mappings ([#171](https://github.com/CategoricalData/hydra/issues/171)).
+- Simplified unit-valued variants in Python ([#206](https://github.com/CategoricalData/hydra/issues/206)).
+- Checked for inconsistencies between Term/TTerm and Type/TType DSLs ([#218](https://github.com/CategoricalData/hydra/issues/218)).
+- GenPG demo: refactored to support Haskell, Python, and Java; Python runner;
+  Java generation; finalized output format.
+- Testing: extended test runners for let hoisting (Haskell, Python, Java);
+  floating-point precision tests; ordering tests for `hydra.lib.maps`/`hydra.lib.sets`;
+  inference tests for inferred System F terms; case-hoisting test cases; new JSON coder tests;
+  thorough test cases for all primitives ([#199](https://github.com/CategoricalData/hydra/issues/199)).
+
+### Bug fixes
+
+- Fixed interpreter bugs causing test failures ([#235](https://github.com/CategoricalData/hydra/issues/235)).
+- Fixed bug in type checking in connection with dead code.
+- Fixed bug in `removeTypesFromTerm`.
+- Fixed bug in `typeOfMap`.
+- Fixed 32-bit max int value in `hydra.constants`.
+- Fixed numeric precision in Python.
+- Added `BigDecimal` support and fixed `uint8` (short) support in Java.
+- Fixed Haskell coder with respect to imports for binary literals.
+- Excluded `Prelude.encodeFloat` and `Prelude.decodeFloat` from generated Haskell
+  due to name collisions.
+- Fixed consistency issues in Python primitives:
+  `hydra.lib.sets.toList`, `hydra.lib.maps.union` (precedence),
+  `hydra.lib.strings.lines`, `hydra.lib.strings.readString` (dequoting),
+  `hydra.lib.lists.apply`, `hydra.lib.maps.toList`.
+- Fixed Haskell type signature of `hydra.lists.span`.
+- Fixed issue with eta expansion of typed terms.
+- Fixed shadowing issue in generated encoding modules.
+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.
+
+### Documentation
+
+- Updated main README with complete implementation status.
+- Added Documentation sections to all implementation READMEs.
+- Fixed outdated Code-organization.md (Python now uses `src/gen-main`).
+- Fixed incorrect code paths in Implementation.md.
+- Added Java section to Testing wiki.
+- Comprehensive developer recipes in `docs/recipes/`.
+- Documentation for tail-call optimization implementation.
+- Added Haddock comments to Haskell primitives.
+- Created wiki page on the release process ([#194](https://github.com/CategoricalData/hydra/issues/194)).
+
+### Community
+
+- Accepted babeloff's `isTrivialTerm` changes.
+
+---
+
+## [0.12.0] - 2025-08-28
+
+A consolidation release: significant Python progress, kernel-level cleanup,
+and a wave of bookkeeping closures for Hydra-Java module ports.
+
+### Breaking changes
+
+- Removed `hydra.decoding` module ([#190](https://github.com/CategoricalData/hydra/issues/190)).
+- Flattened dependency tiers; eliminated tier-1, tier-2, tier-3 organization ([#184](https://github.com/CategoricalData/hydra/issues/184)).
+- Removed `typed` term variant ([#173](https://github.com/CategoricalData/hydra/issues/173), [#162](https://github.com/CategoricalData/hydra/issues/162)).
+- Module naming changes: moved tabular and relational modules into kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).
+- Standardized on uncurried helper functions in term-level DSLs ([#174](https://github.com/CategoricalData/hydra/issues/174)).
+- Renamed `hydra.lib.flows.traverseOptional` to `hydra.lib.flows.mapOptional`.
+- Eliminated camel-cased namespace parts from the kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).
+- Replaced list and optional eliminations with primitive functions ([#150](https://github.com/CategoricalData/hydra/issues/150)).
+- Moved `Hydra.Ext` to hydra-ext ([#178](https://github.com/CategoricalData/hydra/issues/178)); moved 'ext' sources into hydra-ext ([#189](https://github.com/CategoricalData/hydra/issues/189)).
+
+### New features
+
+- Significant progress toward Hydra-Python completion:
+  generated all kernel types and terms into Python;
+  added `Decimal` support for bigfloat values;
+  environment tracking for variable scoping;
+  generated `hydra.languages` into Python;
+  `__hash__` and `__eq__` on serializable generated classes ([#160](https://github.com/CategoricalData/hydra/issues/160)).
+- Designated `unit` term and type variants ([#186](https://github.com/CategoricalData/hydra/issues/186)).
+- `hydra.lib.flows.mapElems` and `hydra.lib.flows.mapKeys` utilities.
+- Promoted JSON coder into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).
+- Promoted JSON utilities into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).
+- C# coder ([#139](https://github.com/CategoricalData/hydra/issues/139)).
+- GQL model and parser ([#140](https://github.com/CategoricalData/hydra/issues/140)).
+- Tabular adapters ([#142](https://github.com/CategoricalData/hydra/issues/142)).
+- Type-level C++ coder ([#170](https://github.com/CategoricalData/hydra/issues/170)).
+- Variable-types-to-Haskell-typedefs transformation ([#70](https://github.com/CategoricalData/hydra/issues/70)).
+- A newline at the end of each generated file ([#154](https://github.com/CategoricalData/hydra/issues/154)).
+- Refactor kernel modules and primitives by connectivity ([#177](https://github.com/CategoricalData/hydra/issues/177)).
+
+### Improvements
+
+- Condensed repeated elements in error traces ([#165](https://github.com/CategoricalData/hydra/issues/165)).
+- Fixed transitive schema dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).
+- Improved adapter solution with respect to literals.
+- Better handling of type variables in Python coder.
+- Enhanced term-level Python generation with proper ordering to minimize forward references.
+- Topo-sort helper function for dependency management.
+- Updated all Python libraries with latest changes.
+- Distinguished between deannotation and detyping of terms.
+- Adapted primitives when applying language constraints to a graph.
+- Use unqualified names where possible in generated code ([#153](https://github.com/CategoricalData/hydra/issues/153)).
+- Eliminated `Data.Graph` (containers) dependency ([#167](https://github.com/CategoricalData/hydra/issues/167)).
+- "Close the loop" demonstration ([#175](https://github.com/CategoricalData/hydra/issues/175)).
+- Implemented `typeOf` ([#168](https://github.com/CategoricalData/hydra/issues/168)).
+
+### Bug fixes
+
+- Fixed System F terms for records and case statements ([#168](https://github.com/CategoricalData/hydra/issues/168)).
+- Fixed issue with transitive type-level module dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).
+- Corrected handling of variable references in Python application terms.
+- Fixed nullary functions in Python (added empty parens).
+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.
+
+### Bookkeeping
+
+- Closed long-standing Hydra-Java module-port issues
+  ([#9](https://github.com/CategoricalData/hydra/issues/9), [#11](https://github.com/CategoricalData/hydra/issues/11), [#15](https://github.com/CategoricalData/hydra/issues/15), [#16](https://github.com/CategoricalData/hydra/issues/16), [#18](https://github.com/CategoricalData/hydra/issues/18), [#19](https://github.com/CategoricalData/hydra/issues/19), [#20](https://github.com/CategoricalData/hydra/issues/20), [#21](https://github.com/CategoricalData/hydra/issues/21), [#22](https://github.com/CategoricalData/hydra/issues/22), [#23](https://github.com/CategoricalData/hydra/issues/23), [#25](https://github.com/CategoricalData/hydra/issues/25), [#44](https://github.com/CategoricalData/hydra/issues/44), [#45](https://github.com/CategoricalData/hydra/issues/45));
+  most of the underlying work shipped in earlier releases.
+- Closed Hydra-Java DSL-port issues ([#24](https://github.com/CategoricalData/hydra/issues/24), [#26](https://github.com/CategoricalData/hydra/issues/26), [#27](https://github.com/CategoricalData/hydra/issues/27), [#28](https://github.com/CategoricalData/hydra/issues/28), [#29](https://github.com/CategoricalData/hydra/issues/29)) and
+  the Scala/Avro tracking issues ([#77](https://github.com/CategoricalData/hydra/issues/77), [#81](https://github.com/CategoricalData/hydra/issues/81)); these had been resolved
+  by earlier releases (Scala in 0.14.0, Avro bidi in 0.14.0).
+
+### Documentation
+
+- Updated Hydra-Haskell README.
+- Updated Hydra-Java README with corrected links.
+- Updated JavaDocs.
+
+---
+
+## [0.11.0] - 2025-03-16
+
+Untagged in-repository version.
+A type-inference rebase release: major restructuring of inference internals
+to align with Algorithm W, plus a sweeping removal of explicit type annotations
+across the kernel.
+
+### Highlights
+
+- **Inference rebased on Algorithm W** ([#118](https://github.com/CategoricalData/hydra/issues/118)): unify-early strategy ([#146](https://github.com/CategoricalData/hydra/issues/146)),
+  infinite-type checks restored ([#116](https://github.com/CategoricalData/hydra/issues/116)), recursive-element inference ([#90](https://github.com/CategoricalData/hydra/issues/90)),
+  unified handling of elements and let bindings ([#112](https://github.com/CategoricalData/hydra/issues/112)), minimized manual
+  type annotations ([#119](https://github.com/CategoricalData/hydra/issues/119)).
+- **`hydra.inference` module** introduced for inference type definitions;
+  substitution and unification moved up a level.
+
+### Breaking changes
+
+- Argument order of `Logic.ifElse` changed ([#147](https://github.com/CategoricalData/hydra/issues/147)).
+
+### New features
+
+- Inference test cases promoted into the common test suite ([#148](https://github.com/CategoricalData/hydra/issues/148));
+  added "kernel examples" inference tests; more recursion / mutual recursion cases.
+
+### Improvements
+
+- Removed type annotations across all kernel sources ([#119](https://github.com/CategoricalData/hydra/issues/119)).
+- Migrated to fully-applied primitive library DSLs ([#157](https://github.com/CategoricalData/hydra/issues/157)).
+- Aligned `Graph` and `Element` with `LetBinding` ([#159](https://github.com/CategoricalData/hydra/issues/159)).
+- `hydra.core.Unit` recognized by the Haskell coder.
+- Refactored inference tests.
+
+### Bug fixes
+
+- Fix for underdetermined type in `hydra.decode`.
+
+---
+
+## [0.10.0] - 2025-02-19
+
+Untagged in-repository version.
+Adds Hydra-Python (initial completion), a GraphSON coder,
+provisional Hydra-Go support, and dot-separated namespace conventions.
+
+### Highlights
+
+- **Hydra-Python initial completion** ([#80](https://github.com/CategoricalData/hydra/issues/80), [#66](https://github.com/CategoricalData/hydra/issues/66)): Python coder, generated kernel
+  modules in Python, and full library implementations across kernel namespaces.
+- **GraphSON coder** ([#79](https://github.com/CategoricalData/hydra/issues/79)).
+- **Provisional Hydra-Go** ([#65](https://github.com/CategoricalData/hydra/issues/65)).
+- **Namespace formatting** standardized to dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).
+
+### Breaking changes
+
+- All namespaces use dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).
+
+### New features
+
+- Hydra-Python: Python coder; generated `hydra.coreEncoding`, `hydra.strip`,
+  `hydra.literals` and other kernel modules in Python; tuple-expression support;
+  updated `hydra.constants` in Python.
+- GraphSON coder ([#79](https://github.com/CategoricalData/hydra/issues/79)).
+- Provisional Hydra-Go ([#65](https://github.com/CategoricalData/hydra/issues/65)).
+- `string-to-char-list` and `char-list-to-string` primitives ([#149](https://github.com/CategoricalData/hydra/issues/149)).
+- Restored normalization for generated term variables ([#145](https://github.com/CategoricalData/hydra/issues/145)).
+
+### Improvements
+
+- Re-leveled dependency tiers ([#135](https://github.com/CategoricalData/hydra/issues/135)).
+- Updated all Java, Haskell, hydra-ext, and Python primitives to current sources.
+
+---
+
+## [0.9.0] - 2025-01-06
+
+Untagged in-repository version.
+Bootstraps Hydra-Python and the JSON Schema coder; introduces a fluent Java DSL for flows.
+
+### Highlights
+
+- **JSON Schema coder** ([#141](https://github.com/CategoricalData/hydra/issues/141)).
+- **Python coder scaffold**: serde, language constraints, and generated Haskell
+  sources for Python.
+- **Fluent-style Java DSL for flows** ([#143](https://github.com/CategoricalData/hydra/issues/143)).
+
+### New features
+
+- JSON Schema coder ([#141](https://github.com/CategoricalData/hydra/issues/141)).
+- Python coder scaffold and serde.
+- Provisional Python language constraints module.
+- Fluent-style Java DSL for flows ([#143](https://github.com/CategoricalData/hydra/issues/143)); moved Flows DSL into `hydra.dsl`.
+- New `hydra.coders` DSL.
+- New DSL functions for core variants.
+
+### Improvements
+
+- Generalized `Namespaces` so it can be used for languages other than Haskell.
+- Local-name-only Python type aliases (the directory tree provides the namespace).
+- Coders DSL used to simplify Java language-constraint sources.
+- Removed redundant productions in the Python grammar.
+- Added unit tests for fluent flows.
+
+### Documentation
+
+- Updated JavaDocs for 0.9.0.
+
+---
+
+## [0.8.1] - 2024-09-24
+
+Patch release.
+
+### Improvements
+
+- Generalized the property graph merging utility to accept type systems other than Hydra Core.
+
+---
+
+## [0.8.0] - 2024-09-09
+
+C# support ([#139](https://github.com/CategoricalData/hydra/issues/139)), Graphviz DOT coder, term accessors, and a small breaking change in Java
+to support Spark.
+
+### Breaking changes
+
+- Made `FlowException` serializable for Spark support (may affect existing error handling).
+
+### New features
+
+- C# syntax module based on the Microsoft ANTLR grammar ([#139](https://github.com/CategoricalData/hydra/issues/139)).
+- Graphviz DOT coder ([#136](https://github.com/CategoricalData/hydra/issues/136)):
+  full support for lambdas and recursive `let` statements;
+  compact 'accessor graph' visualization option;
+  customizable label styles;
+  highlighted let-bound terms; edge labels.
+- Term accessor type to facilitate lenses and path-aware transformations.
+- OpenGQL grammar and generated Haskell for the OpenGQL model ([#140](https://github.com/CategoricalData/hydra/issues/140)).
+
+### Improvements
+
+- Added `</>` as alternative to `@@` application operator in Haskell DSLs.
+- Utilities for working with term accessors.
+- More specific exception class for JSON decoding.
+- Additional convenience methods on `JsonDecoding.java`.
+- Used transitive dependencies in hydra-java and hydra-ext.
+- Upgraded ANTLR to address a vulnerability.
+- Moved TinkerPop utilities from `hydra/ext/org/apache/tinkerpop` into `hydra/pg`.
+
+---
+
+## [0.7.0] - 2024-08-21
+
+Major refactoring of module organization and namespace management.
+Establishes the DNS-style namespace convention in hydra-ext
+and lifts property-graph models into a top-level `hydra/pg` namespace.
+
+### Breaking changes
+
+- Namespace reorganization: migrated to DNS-based module naming in hydra-ext ([#138](https://github.com/CategoricalData/hydra/issues/138)):
+  `hydra/ext/avro` → `hydra/ext/org/apache/avro`,
+  `hydra/ext/graphql` → `hydra/ext/org/graphql`,
+  `hydra/ext/yaml` → `hydra/ext/org/yaml`,
+  `hydra/ext/json/decoding` → `hydra/ext/org/json/decoding`,
+  `hydra/ext/rdf` → `hydra/ext/org/w3/rdf`,
+  `hydra/ext/shacl` → `hydra/ext/org/w3/shacl`,
+  `hydra/ext/tinkerpop` → `hydra/ext/org/apache/tinkerpop`.
+- Property graphs: promoted property graph modules from
+  `hydra/ext/org/apache/tinkerpop` to `hydra/pg`.
+- Project structure: renamed `hydra-extensions` to `hydra-ext`;
+  renamed `hydra/langs` to `hydra/ext` ([#138](https://github.com/CategoricalData/hydra/issues/138));
+  made hydra-ext into a Gradle subproject alongside hydra-java;
+  added top-level Gradle build.
+
+### Improvements
+
+- Moved TinkerPop modules from hydra-haskell into hydra-ext for better separation.
+- Moved miscellaneous models to `Hydra.Ext.Other` ([#138](https://github.com/CategoricalData/hydra/issues/138)).
+- Moved XML Schema, SQL, ShEx, and OWL models to hydra-ext.
+- Moved KQL, Parquet, and Python modules to hydra-ext.
+- Separated JavaDocs for hydra-java and hydra-ext.
+- Updated publishing configuration in `build.gradle`.
+
+---
+
+## [0.6.0] - 2024-08-19
+
+Type-system improvements (System F type abstraction/application; eliminated polymorphic
+types from Hydra Core), expanded language support (Graphviz DOT model, generated Java
+field-name constants), and revamped annotation handling.
+
+### Breaking changes
+
+- Eliminated `InferenceContext` helper type ([#103](https://github.com/CategoricalData/hydra/issues/103)).
+- Changed typing environment from `Map Name Type` to `Map Name TypeScheme` in graphs ([#76](https://github.com/CategoricalData/hydra/issues/76)).
+- Updated annotations and flows to use `map<Name, Term>` instead of `map<string, Term>` ([#133](https://github.com/CategoricalData/hydra/issues/133)).
+- Unified `Name` and `FieldName`; aliased to `string` ([#121](https://github.com/CategoricalData/hydra/issues/121)).
+- Renamed `hydra/core.UnitType` to `hydra/core.Unit` ([#123](https://github.com/CategoricalData/hydra/issues/123)).
+- Eliminated annotation classes; Hydra has a single built-in notion of annotations ([#113](https://github.com/CategoricalData/hydra/issues/113)).
+- Unified the `Nominal` type with `RowType` ([#115](https://github.com/CategoricalData/hydra/issues/115)).
+- Removed the `extends` parameter for row types ([#132](https://github.com/CategoricalData/hydra/issues/132)).
+- Replaced `hydra/Kv` with `hydra/Annotations` (rename revisited).
+
+### New features
+
+- System F support: `typeAbstraction` and `typeApplication` term constructors.
+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).
+- Graphviz DOT model and initial support ([#136](https://github.com/CategoricalData/hydra/issues/136)).
+- Field-name constants generated in Java code generation ([#137](https://github.com/CategoricalData/hydra/issues/137)).
+- Provisional Algorithm W implementation in Haskell (originally from @wisnesky), kept for reference.
+
+### Improvements
+
+- Primitive organization: Hydra primitives organized into libraries for namespace management.
+- Code generation:
+  - Escaped field name constants and `with_` methods in Java coder.
+  - Generated field name constants in Java ([#137](https://github.com/CategoricalData/hydra/issues/137)).
+  - Avoided duplicated comments in wrapper classes in generated Java.
+  - Removed superfluous newtype comments in Haskell coder.
+- Updated Delta Parquet model to follow the Java API more closely.
+- Enriched OpenCypher features module with the complete list of standard Cypher functions.
+- Added convenience methods to `JsonEncoding.java`.
+- Restored `Hydra.Inference` subdirectory.
+- Allowed arbitrary case for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).
+- Corrected `uint8` representation in Java to `Short` ([#120](https://github.com/CategoricalData/hydra/issues/120)).
+
+### Bug fixes
+
+- Fixed handling of type annotations in term adapters.
+- Fixed decoding of encoded terms annotated with a type.
+- Corrected encoding of universal types in `showTerm` ([#117](https://github.com/CategoricalData/hydra/issues/117)).
+
+---
+
+## [0.5.3] - 2024-08-06
+
+Patch release.
+Preserves order of map key/value pairs and set elements during JSON serialization.
+
+### Bug fixes
+
+- Preserved ordering of key/value pairs and set elements in JSON output.
+
+### New features
+
+- Polymorphic `equal` primitive in Haskell and Java.
+- Generated Hydra type definitions together with native instantiations of Hydra types
+  in Haskell (a stepping stone toward generated coders, [#47](https://github.com/CategoricalData/hydra/issues/47)).
+
+---
+
+## [0.5.1] - 2024-08-01
+
+Patch release.
+Dependency updates and minor improvements following the 0.5.0 Hydra Core overhaul.
+
+### Improvements
+
+- Updated dependencies.
+
+---
+
+## [0.5.0] - 2024-07-26
+
+Untagged in-repository version.
+Major Hydra Core overhaul: eliminates polymorphic types in favor of explicit
+TypeScheme; consolidates the annotation system; revamps `Let` term encoding.
+
+### Breaking changes
+
+- Eliminated polymorphic types from Hydra Core in Haskell ([#125](https://github.com/CategoricalData/hydra/issues/125)):
+  removed type parameters from `hydra/core` types in Hydra-Java; replaced type schemes
+  with forall types ([#76](https://github.com/CategoricalData/hydra/issues/76)).
+- Revamped core encoding and `Let`: bindings are now a list of
+  `(name, term, optional type scheme)` triplets instead of a map.
+- Unified typed-term types and moved `TypeScheme` into Hydra Core.
+- Eliminated `AnnotationClass`; Hydra has a single built-in notion of annotations now ([#113](https://github.com/CategoricalData/hydra/issues/113)).
+- Renamed and refactored phantom-type wrappers ([#128](https://github.com/CategoricalData/hydra/issues/128)); removed deprecated `Reference`
+  type from `hydra/phantoms`.
+- Removed incomplete support for stream types and stream terms ([#88](https://github.com/CategoricalData/hydra/issues/88)).
+
+### New features
+
+- `LiteralTypes` DSL module so literals can be built independently of terms.
+- `Hydra.Minimal` module to facilitate collaboration on Hydra application prototypes.
+- `TypeConstraint` type added to the kernel.
+- `foldl` primitive in Haskell and Java; DSL uses `foldl` instead of the built-in
+  list elimination term by default.
+
+### Improvements
+
+- Improvements to Java and JSON coders; improved untyped JSON coder.
+- Pre-order and post-order term-traversal test cases added.
+- Refactored type inference tests.
+- Restored generated Java (Core through Tier 3) with only a few manual tweaks.
+- Element names allow arbitrary case ([#7](https://github.com/CategoricalData/hydra/issues/7)).
+
+---
+
+## [0.4.0] - 2024-07-10
+
+Untagged in-repository version.
+Adds null checks to generated Java (breaking, but justified — Hydra-Java disallows nulls),
+the Gremlin model, and Protobuf annotation refinements.
+
+### Breaking changes
+
+- Null checks added to constructors and `withXXX()` methods in generated Java;
+  null values are no longer permitted in Hydra-Java.
+- Removed Java 8 restriction (raised minimum Java version).
+
+### New features
+
+- Gremlin model ([#127](https://github.com/CategoricalData/hydra/issues/127)); generated Haskell for Gremlin.
+- `hydra/lib/lists.safeHead` primitive in Haskell (necessary in Java due to eager evaluation).
+- Support for Protobuf `deprecated=true` annotation; non-string Protobuf options.
+- Java options in generated Protobuf.
+
+### Improvements
+
+- Used `java.util.Objects.requireNonNull` instead of a custom null check in generated Java.
+- Added 'automatically generated file' disclaimer to generated Java files.
+- Added autogen comments and null checks to (most) generated Java.
+- Added necessary schema-level dependencies for built-in modules.
+- Added null checks to the Flows DSL in Java.
+
+---
+
+## [0.3.0] - 2024-06-05
+
+Untagged in-repository version.
+Adds an OpenCypher parser based on an ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124)),
+a KQL (Kusto Query Language) model and serializer,
+a Delta Parquet model,
+and an early property graph queries model in the style of Cypher.
+
+### New features
+
+- OpenCypher parser based on the OpenCypher M23 ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124));
+  ANTLR added as a build dependency;
+  large Cypher test suite drawn from the Cypher Manual.
+- Cypher-to-PG-query transformer (Java; partially implemented).
+- Property graph queries DSL and generated property graph query classes in Java.
+- Property graph queries model (Cypher / future GQL style).
+- KQL (Kusto Query Language) initial model and basic serializer.
+- Delta Parquet model with generated sources.
+
+### Improvements
+
+- Java options and `deprecated=true` support in generated Protobuf.
+- Convenience methods in Java.
+
+---
+
+## [0.2.0] - 2024-01-10
+
+Hydra-Java 0.2.0 release.
+Significant Java tooling and DSL build-out, Protobuf bidirectional coder,
+Python3 syntax model ([#80](https://github.com/CategoricalData/hydra/issues/80)), property graph validation ([#100](https://github.com/CategoricalData/hydra/issues/100)),
+JSON bidirectional support in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)),
+OpenCypher initial model ([#108](https://github.com/CategoricalData/hydra/issues/108)),
+Cypher unification, and the start of the typed-DSL story in Haskell.
+
+### New features
+
+- Property graph validation: validator type, optionality on property types,
+  customizable id/property handling in the merging adapter, fine-tuned validation,
+  comprehensive unit tests in Java ([#100](https://github.com/CategoricalData/hydra/issues/100)).
+- Bidirectional JSON serialization/deserialization in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)).
+- Checkstyle configuration based on Google style guide ([#111](https://github.com/CategoricalData/hydra/issues/111)).
+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).
+- Initial OpenCypher model and parser scaffold ([#108](https://github.com/CategoricalData/hydra/issues/108)).
+- Protobuf coder ([#99](https://github.com/CategoricalData/hydra/issues/99)): type encoder, field numbering, formatting, deprecated annotation,
+  Java options, non-string options.
+- Adapter framework tolerance of recursive types ([#58](https://github.com/CategoricalData/hydra/issues/58)); default branch for case
+  statements ([#60](https://github.com/CategoricalData/hydra/issues/60)).
+- Topological sort in type inference ([#67](https://github.com/CategoricalData/hydra/issues/67)).
+- `hydra/query` model ([#73](https://github.com/CategoricalData/hydra/issues/73)).
+- Records-to-TinkerPop-elements coder ([#64](https://github.com/CategoricalData/hydra/issues/64)).
+- Equality primitives for all literal types ([#92](https://github.com/CategoricalData/hydra/issues/92)); polymorphic logic primitives ([#95](https://github.com/CategoricalData/hydra/issues/95)).
+- `mapKeys` primitive ([#93](https://github.com/CategoricalData/hydra/issues/93)).
+- Tuple support in Java ([#94](https://github.com/CategoricalData/hydra/issues/94)).
+- Java 8 as an optional target ([#96](https://github.com/CategoricalData/hydra/issues/96)); optionally generate Java classes as `Serializable` ([#97](https://github.com/CategoricalData/hydra/issues/97)).
+- Bidirectional "merged vertex" and "merged edge" coders ([#106](https://github.com/CategoricalData/hydra/issues/106)).
+- Nullability and parameterization in the tabular model ([#107](https://github.com/CategoricalData/hydra/issues/107)).
+- Term-level / type-level dependency distinction for modules ([#109](https://github.com/CategoricalData/hydra/issues/109)).
+- Flatten nested `let` terms for transformation into Java ([#110](https://github.com/CategoricalData/hydra/issues/110)).
+- Various `Flow` utilities in Java: `bind3`; convenience methods for consuming results;
+  `fromFlow` variants including one that throws.
+
+### Improvements
+
+- Hydra-Java module ports ([#10](https://github.com/CategoricalData/hydra/issues/10), [#12](https://github.com/CategoricalData/hydra/issues/12), [#13](https://github.com/CategoricalData/hydra/issues/13), [#14](https://github.com/CategoricalData/hydra/issues/14), [#17](https://github.com/CategoricalData/hydra/issues/17), [#30](https://github.com/CategoricalData/hydra/issues/30), [#31](https://github.com/CategoricalData/hydra/issues/31), [#32](https://github.com/CategoricalData/hydra/issues/32), [#33](https://github.com/CategoricalData/hydra/issues/33), [#34](https://github.com/CategoricalData/hydra/issues/34), [#35](https://github.com/CategoricalData/hydra/issues/35),
+  [#38](https://github.com/CategoricalData/hydra/issues/38), [#39](https://github.com/CategoricalData/hydra/issues/39), [#41](https://github.com/CategoricalData/hydra/issues/41), [#43](https://github.com/CategoricalData/hydra/issues/43), [#48](https://github.com/CategoricalData/hydra/issues/48), [#71](https://github.com/CategoricalData/hydra/issues/71), [#72](https://github.com/CategoricalData/hydra/issues/72), [#75](https://github.com/CategoricalData/hydra/issues/75), [#83](https://github.com/CategoricalData/hydra/issues/83)):
+  `Common`, `CoreEncoding`, `CoreLanguage`, `Kernel`, `Flows`, `Lists`, `Literals`,
+  `Math`, `Sets`, `Strings`, `Optionals`, `Maps`, `Flows` primitives, `Sets` primitives.
+- Common DSLs in Haskell: Flow support ([#68](https://github.com/CategoricalData/hydra/issues/68)), Let support ([#69](https://github.com/CategoricalData/hydra/issues/69)).
+- Renamed annotation type parameter `m` to `a` ([#41](https://github.com/CategoricalData/hydra/issues/41)).
+- Updated wrapper, element, and variable types ([#75](https://github.com/CategoricalData/hydra/issues/75)).
+- Removed `schema` field from `Element` ([#83](https://github.com/CategoricalData/hydra/issues/83)).
+- GraphQL coder ([#78](https://github.com/CategoricalData/hydra/issues/78)).
+- Code quality:
+  - Updated main and test sources to conform to Checkstyle configuration ([#111](https://github.com/CategoricalData/hydra/issues/111)).
+  - Extended line-length limit from 100 to 120 characters.
+  - Disabled overly restrictive indentation and import-order rules.
+  - Disabled `RightCurlyAlone` for compact inline map definitions.
+- Streamlined property-graph element merging to unify properties with identical
+  keys and types ([#106](https://github.com/CategoricalData/hydra/issues/106)).
+- Convenience functions for printing literals and literal types in the Java DSL.
+- Minor addition to JSON decoding.
+- DSL convenience: alphabetic-case flexibility for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).
+
+### Bug fixes
+
+- Fixed type annotations for the Sets Java port ([#48](https://github.com/CategoricalData/hydra/issues/48)).
+- Various minor fixes during the Java module ports.
+
+---
+
+## [0.1.1] - 2022-12-04
+
+Patch release the same day as 0.1.0.
+README polish only.
+
+---
+
+## [0.1.0] - 2022-12-04
+
+First packaged release of Hydra (Hackage).
+This release contains the complete foundation of Hydra.
+
+### Core language
+
+- Hydra's core type and data languages (`hydra.core`).
+- Core models for graphs and modules.
+- Computation model with the `Flow` monad.
+- BNF grammars support.
+- Phantom types.
+- Basic operations on types and terms.
+
+### Type system
+
+- Hindley–Milner-style type inference.
+- Type schemes with polymorphism.
+- Type/term validation.
+
+### Transformations
+
+- Adapter system: type-to-type rewriting and transformation.
+- Coders:
+  Haskell coder (types and terms),
+  Java coder (types and terms),
+  partial Scala coder (terms only),
+  Avro coder,
+  JSON coder,
+  PDL (Pegasus Data Language) coder,
+  RDF + SHACL coder,
+  YAML coder.
+
+### Language support
+
+- Models for GraphQL, OWL (Web Ontology Language), ShEx (Shape Expressions),
+  and TinkerPop-style property graphs.
+
+### Developer tools
+
+- Type-construction DSL and term-construction DSL.
+- QuickCheck property-based tests.
+
+### Implementations
+
+- Hydra-Haskell: bootstrapping implementation with full kernel.
+- Hydra-Java: Java implementation with mature tooling.
+
+### Community
+
+- Set up the LambdaGraph Discord server ([#2](https://github.com/CategoricalData/hydra/issues/2)).
+
+---
+
+## Contributing
+
+We welcome contributions! Please see:
+
+- [Developer recipes](https://github.com/CategoricalData/hydra/tree/main/docs/recipes)
+- [LambdaGraph Discord](https://bit.ly/lg-discord)
+
+## Release process
+
+See the [Release policy](https://github.com/CategoricalData/hydra/wiki/Release-policy)
+wiki page and [docs/release-workflow.md](docs/release-workflow.md)
+for information on how Hydra releases are versioned, built, and published.
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/NOTICE b/NOTICE
new file mode 100644
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,3 @@
+Hydra
+Copyright 2021-2026 The Hydra authors
+https://github.com/CategoricalData/hydra
diff --git a/hydra-bench.cabal b/hydra-bench.cabal
new file mode 100644
--- /dev/null
+++ b/hydra-bench.cabal
@@ -0,0 +1,41 @@
+cabal-version: 1.12
+
+-- This file has been generated from package.yaml by hpack version 0.39.1.
+--
+-- see: https://github.com/sol/hpack
+
+name:           hydra-bench
+version:        0.17.0
+synopsis:       Hydra synthetic inference-benchmark workloads
+description:    Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". Synthetic inference benchmark workloads for cross-host performance comparison. Not part of the standard sync; regenerate on demand via bin/sync-bench.sh.
+category:       Data
+homepage:       https://github.com/CategoricalData/hydra#readme
+bug-reports:    https://github.com/CategoricalData/hydra/issues
+author:         Joshua Shinavier <josh@fortytwo.net>
+maintainer:     Joshua Shinavier <josh@fortytwo.net>
+license:        Apache-2.0
+license-file:   LICENSE
+build-type:     Simple
+extra-source-files:
+    LICENSE
+    NOTICE
+    CHANGELOG.md
+
+source-repository head
+  type: git
+  location: https://github.com/CategoricalData/hydra
+
+library
+  exposed-modules:
+      Hydra.Bench.FanOut
+      Hydra.Bench.LinearChain
+      Hydra.Bench.PolymorphicChain
+  other-modules:
+      Paths_hydra_bench
+  hs-source-dirs:
+      src/main/haskell
+  build-depends:
+      base >=4.19.0 && <4.22
+    , hydra-kernel ==0.17.0
+    , scientific >=0.3.7 && <0.4
+  default-language: Haskell2010
diff --git a/src/main/haskell/Hydra/Bench/FanOut.hs b/src/main/haskell/Hydra/Bench/FanOut.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Bench/FanOut.hs
@@ -0,0 +1,7614 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | Fan-out inference benchmark. Each fanWalker_K branches to three smaller fanWalkers via _Term cases — closer to real codegen DAG shape than LinearChain.
+
+module Hydra.Bench.FanOut where
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Strip as Strip
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+-- | Fan-out walker level 0; branches to fanWalker0, fanWalker0, fanWalker0.
+fanWalker0 :: t0 -> Maybe t0
+fanWalker0 t = Just t
+-- | Fan-out walker level 1; branches to fanWalker0, fanWalker0, fanWalker0.
+fanWalker1 :: Core.Term -> Maybe Core.Term
+fanWalker1 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker0 fun) (fanWalker0 arg) (\_ -> fanWalker0 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker0 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker0 body) Nothing (\inner -> fanWalker0 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 10; branches to fanWalker9, fanWalker5, fanWalker7.
+fanWalker10 :: Core.Term -> Maybe Core.Term
+fanWalker10 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker9 fun) (fanWalker9 arg) (\_ -> fanWalker9 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker5 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker7 body) Nothing (\inner -> fanWalker7 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 100; branches to fanWalker99, fanWalker50, fanWalker67.
+fanWalker100 :: Core.Term -> Maybe Core.Term
+fanWalker100 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker99 fun) (fanWalker99 arg) (\_ -> fanWalker99 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker50 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker67 body) Nothing (\inner -> fanWalker67 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 101; branches to fanWalker100, fanWalker51, fanWalker68.
+fanWalker101 :: Core.Term -> Maybe Core.Term
+fanWalker101 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker100 fun) (fanWalker100 arg) (\_ -> fanWalker100 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker51 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker68 body) Nothing (\inner -> fanWalker68 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 102; branches to fanWalker101, fanWalker51, fanWalker68.
+fanWalker102 :: Core.Term -> Maybe Core.Term
+fanWalker102 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker101 fun) (fanWalker101 arg) (\_ -> fanWalker101 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker51 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker68 body) Nothing (\inner -> fanWalker68 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 103; branches to fanWalker102, fanWalker52, fanWalker69.
+fanWalker103 :: Core.Term -> Maybe Core.Term
+fanWalker103 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker102 fun) (fanWalker102 arg) (\_ -> fanWalker102 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker52 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker69 body) Nothing (\inner -> fanWalker69 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 104; branches to fanWalker103, fanWalker52, fanWalker70.
+fanWalker104 :: Core.Term -> Maybe Core.Term
+fanWalker104 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker103 fun) (fanWalker103 arg) (\_ -> fanWalker103 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker52 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker70 body) Nothing (\inner -> fanWalker70 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 105; branches to fanWalker104, fanWalker53, fanWalker70.
+fanWalker105 :: Core.Term -> Maybe Core.Term
+fanWalker105 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker104 fun) (fanWalker104 arg) (\_ -> fanWalker104 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker53 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker70 body) Nothing (\inner -> fanWalker70 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 106; branches to fanWalker105, fanWalker53, fanWalker71.
+fanWalker106 :: Core.Term -> Maybe Core.Term
+fanWalker106 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker105 fun) (fanWalker105 arg) (\_ -> fanWalker105 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker53 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker71 body) Nothing (\inner -> fanWalker71 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 107; branches to fanWalker106, fanWalker54, fanWalker72.
+fanWalker107 :: Core.Term -> Maybe Core.Term
+fanWalker107 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker106 fun) (fanWalker106 arg) (\_ -> fanWalker106 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker54 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker72 body) Nothing (\inner -> fanWalker72 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 108; branches to fanWalker107, fanWalker54, fanWalker72.
+fanWalker108 :: Core.Term -> Maybe Core.Term
+fanWalker108 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker107 fun) (fanWalker107 arg) (\_ -> fanWalker107 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker54 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker72 body) Nothing (\inner -> fanWalker72 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 109; branches to fanWalker108, fanWalker55, fanWalker73.
+fanWalker109 :: Core.Term -> Maybe Core.Term
+fanWalker109 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker108 fun) (fanWalker108 arg) (\_ -> fanWalker108 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker55 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker73 body) Nothing (\inner -> fanWalker73 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 11; branches to fanWalker10, fanWalker6, fanWalker8.
+fanWalker11 :: Core.Term -> Maybe Core.Term
+fanWalker11 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker10 fun) (fanWalker10 arg) (\_ -> fanWalker10 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker6 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker8 body) Nothing (\inner -> fanWalker8 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 110; branches to fanWalker109, fanWalker55, fanWalker74.
+fanWalker110 :: Core.Term -> Maybe Core.Term
+fanWalker110 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker109 fun) (fanWalker109 arg) (\_ -> fanWalker109 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker55 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker74 body) Nothing (\inner -> fanWalker74 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 111; branches to fanWalker110, fanWalker56, fanWalker74.
+fanWalker111 :: Core.Term -> Maybe Core.Term
+fanWalker111 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker110 fun) (fanWalker110 arg) (\_ -> fanWalker110 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker56 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker74 body) Nothing (\inner -> fanWalker74 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 112; branches to fanWalker111, fanWalker56, fanWalker75.
+fanWalker112 :: Core.Term -> Maybe Core.Term
+fanWalker112 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker111 fun) (fanWalker111 arg) (\_ -> fanWalker111 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker56 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker75 body) Nothing (\inner -> fanWalker75 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 113; branches to fanWalker112, fanWalker57, fanWalker76.
+fanWalker113 :: Core.Term -> Maybe Core.Term
+fanWalker113 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker112 fun) (fanWalker112 arg) (\_ -> fanWalker112 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker57 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker76 body) Nothing (\inner -> fanWalker76 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 114; branches to fanWalker113, fanWalker57, fanWalker76.
+fanWalker114 :: Core.Term -> Maybe Core.Term
+fanWalker114 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker113 fun) (fanWalker113 arg) (\_ -> fanWalker113 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker57 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker76 body) Nothing (\inner -> fanWalker76 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 115; branches to fanWalker114, fanWalker58, fanWalker77.
+fanWalker115 :: Core.Term -> Maybe Core.Term
+fanWalker115 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker114 fun) (fanWalker114 arg) (\_ -> fanWalker114 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker58 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker77 body) Nothing (\inner -> fanWalker77 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 116; branches to fanWalker115, fanWalker58, fanWalker78.
+fanWalker116 :: Core.Term -> Maybe Core.Term
+fanWalker116 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker115 fun) (fanWalker115 arg) (\_ -> fanWalker115 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker58 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker78 body) Nothing (\inner -> fanWalker78 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 117; branches to fanWalker116, fanWalker59, fanWalker78.
+fanWalker117 :: Core.Term -> Maybe Core.Term
+fanWalker117 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker116 fun) (fanWalker116 arg) (\_ -> fanWalker116 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker59 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker78 body) Nothing (\inner -> fanWalker78 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 118; branches to fanWalker117, fanWalker59, fanWalker79.
+fanWalker118 :: Core.Term -> Maybe Core.Term
+fanWalker118 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker117 fun) (fanWalker117 arg) (\_ -> fanWalker117 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker59 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker79 body) Nothing (\inner -> fanWalker79 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 119; branches to fanWalker118, fanWalker60, fanWalker80.
+fanWalker119 :: Core.Term -> Maybe Core.Term
+fanWalker119 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker118 fun) (fanWalker118 arg) (\_ -> fanWalker118 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker60 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker80 body) Nothing (\inner -> fanWalker80 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 12; branches to fanWalker11, fanWalker6, fanWalker8.
+fanWalker12 :: Core.Term -> Maybe Core.Term
+fanWalker12 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker11 fun) (fanWalker11 arg) (\_ -> fanWalker11 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker6 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker8 body) Nothing (\inner -> fanWalker8 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 120; branches to fanWalker119, fanWalker60, fanWalker80.
+fanWalker120 :: Core.Term -> Maybe Core.Term
+fanWalker120 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker119 fun) (fanWalker119 arg) (\_ -> fanWalker119 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker60 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker80 body) Nothing (\inner -> fanWalker80 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 121; branches to fanWalker120, fanWalker61, fanWalker81.
+fanWalker121 :: Core.Term -> Maybe Core.Term
+fanWalker121 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker120 fun) (fanWalker120 arg) (\_ -> fanWalker120 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker61 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker81 body) Nothing (\inner -> fanWalker81 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 122; branches to fanWalker121, fanWalker61, fanWalker82.
+fanWalker122 :: Core.Term -> Maybe Core.Term
+fanWalker122 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker121 fun) (fanWalker121 arg) (\_ -> fanWalker121 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker61 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker82 body) Nothing (\inner -> fanWalker82 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 123; branches to fanWalker122, fanWalker62, fanWalker82.
+fanWalker123 :: Core.Term -> Maybe Core.Term
+fanWalker123 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker122 fun) (fanWalker122 arg) (\_ -> fanWalker122 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker62 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker82 body) Nothing (\inner -> fanWalker82 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 124; branches to fanWalker123, fanWalker62, fanWalker83.
+fanWalker124 :: Core.Term -> Maybe Core.Term
+fanWalker124 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker123 fun) (fanWalker123 arg) (\_ -> fanWalker123 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker62 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker83 body) Nothing (\inner -> fanWalker83 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 125; branches to fanWalker124, fanWalker63, fanWalker84.
+fanWalker125 :: Core.Term -> Maybe Core.Term
+fanWalker125 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker124 fun) (fanWalker124 arg) (\_ -> fanWalker124 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker63 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker84 body) Nothing (\inner -> fanWalker84 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 126; branches to fanWalker125, fanWalker63, fanWalker84.
+fanWalker126 :: Core.Term -> Maybe Core.Term
+fanWalker126 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker125 fun) (fanWalker125 arg) (\_ -> fanWalker125 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker63 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker84 body) Nothing (\inner -> fanWalker84 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 127; branches to fanWalker126, fanWalker64, fanWalker85.
+fanWalker127 :: Core.Term -> Maybe Core.Term
+fanWalker127 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker126 fun) (fanWalker126 arg) (\_ -> fanWalker126 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker64 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker85 body) Nothing (\inner -> fanWalker85 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 128; branches to fanWalker127, fanWalker64, fanWalker86.
+fanWalker128 :: Core.Term -> Maybe Core.Term
+fanWalker128 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker127 fun) (fanWalker127 arg) (\_ -> fanWalker127 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker64 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker86 body) Nothing (\inner -> fanWalker86 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 129; branches to fanWalker128, fanWalker65, fanWalker86.
+fanWalker129 :: Core.Term -> Maybe Core.Term
+fanWalker129 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker128 fun) (fanWalker128 arg) (\_ -> fanWalker128 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker65 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker86 body) Nothing (\inner -> fanWalker86 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 13; branches to fanWalker12, fanWalker7, fanWalker9.
+fanWalker13 :: Core.Term -> Maybe Core.Term
+fanWalker13 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker12 fun) (fanWalker12 arg) (\_ -> fanWalker12 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker7 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker9 body) Nothing (\inner -> fanWalker9 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 130; branches to fanWalker129, fanWalker65, fanWalker87.
+fanWalker130 :: Core.Term -> Maybe Core.Term
+fanWalker130 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker129 fun) (fanWalker129 arg) (\_ -> fanWalker129 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker65 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker87 body) Nothing (\inner -> fanWalker87 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 131; branches to fanWalker130, fanWalker66, fanWalker88.
+fanWalker131 :: Core.Term -> Maybe Core.Term
+fanWalker131 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker130 fun) (fanWalker130 arg) (\_ -> fanWalker130 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker66 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker88 body) Nothing (\inner -> fanWalker88 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 132; branches to fanWalker131, fanWalker66, fanWalker88.
+fanWalker132 :: Core.Term -> Maybe Core.Term
+fanWalker132 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker131 fun) (fanWalker131 arg) (\_ -> fanWalker131 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker66 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker88 body) Nothing (\inner -> fanWalker88 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 133; branches to fanWalker132, fanWalker67, fanWalker89.
+fanWalker133 :: Core.Term -> Maybe Core.Term
+fanWalker133 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker132 fun) (fanWalker132 arg) (\_ -> fanWalker132 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker67 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker89 body) Nothing (\inner -> fanWalker89 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 134; branches to fanWalker133, fanWalker67, fanWalker90.
+fanWalker134 :: Core.Term -> Maybe Core.Term
+fanWalker134 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker133 fun) (fanWalker133 arg) (\_ -> fanWalker133 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker67 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker90 body) Nothing (\inner -> fanWalker90 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 135; branches to fanWalker134, fanWalker68, fanWalker90.
+fanWalker135 :: Core.Term -> Maybe Core.Term
+fanWalker135 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker134 fun) (fanWalker134 arg) (\_ -> fanWalker134 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker68 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker90 body) Nothing (\inner -> fanWalker90 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 136; branches to fanWalker135, fanWalker68, fanWalker91.
+fanWalker136 :: Core.Term -> Maybe Core.Term
+fanWalker136 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker135 fun) (fanWalker135 arg) (\_ -> fanWalker135 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker68 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker91 body) Nothing (\inner -> fanWalker91 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 137; branches to fanWalker136, fanWalker69, fanWalker92.
+fanWalker137 :: Core.Term -> Maybe Core.Term
+fanWalker137 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker136 fun) (fanWalker136 arg) (\_ -> fanWalker136 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker69 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker92 body) Nothing (\inner -> fanWalker92 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 138; branches to fanWalker137, fanWalker69, fanWalker92.
+fanWalker138 :: Core.Term -> Maybe Core.Term
+fanWalker138 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker137 fun) (fanWalker137 arg) (\_ -> fanWalker137 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker69 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker92 body) Nothing (\inner -> fanWalker92 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 139; branches to fanWalker138, fanWalker70, fanWalker93.
+fanWalker139 :: Core.Term -> Maybe Core.Term
+fanWalker139 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker138 fun) (fanWalker138 arg) (\_ -> fanWalker138 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker70 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker93 body) Nothing (\inner -> fanWalker93 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 14; branches to fanWalker13, fanWalker7, fanWalker10.
+fanWalker14 :: Core.Term -> Maybe Core.Term
+fanWalker14 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker13 fun) (fanWalker13 arg) (\_ -> fanWalker13 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker7 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker10 body) Nothing (\inner -> fanWalker10 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 140; branches to fanWalker139, fanWalker70, fanWalker94.
+fanWalker140 :: Core.Term -> Maybe Core.Term
+fanWalker140 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker139 fun) (fanWalker139 arg) (\_ -> fanWalker139 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker70 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker94 body) Nothing (\inner -> fanWalker94 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 141; branches to fanWalker140, fanWalker71, fanWalker94.
+fanWalker141 :: Core.Term -> Maybe Core.Term
+fanWalker141 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker140 fun) (fanWalker140 arg) (\_ -> fanWalker140 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker71 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker94 body) Nothing (\inner -> fanWalker94 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 142; branches to fanWalker141, fanWalker71, fanWalker95.
+fanWalker142 :: Core.Term -> Maybe Core.Term
+fanWalker142 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker141 fun) (fanWalker141 arg) (\_ -> fanWalker141 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker71 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker95 body) Nothing (\inner -> fanWalker95 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 143; branches to fanWalker142, fanWalker72, fanWalker96.
+fanWalker143 :: Core.Term -> Maybe Core.Term
+fanWalker143 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker142 fun) (fanWalker142 arg) (\_ -> fanWalker142 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker72 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker96 body) Nothing (\inner -> fanWalker96 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 144; branches to fanWalker143, fanWalker72, fanWalker96.
+fanWalker144 :: Core.Term -> Maybe Core.Term
+fanWalker144 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker143 fun) (fanWalker143 arg) (\_ -> fanWalker143 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker72 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker96 body) Nothing (\inner -> fanWalker96 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 145; branches to fanWalker144, fanWalker73, fanWalker97.
+fanWalker145 :: Core.Term -> Maybe Core.Term
+fanWalker145 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker144 fun) (fanWalker144 arg) (\_ -> fanWalker144 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker73 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker97 body) Nothing (\inner -> fanWalker97 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 146; branches to fanWalker145, fanWalker73, fanWalker98.
+fanWalker146 :: Core.Term -> Maybe Core.Term
+fanWalker146 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker145 fun) (fanWalker145 arg) (\_ -> fanWalker145 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker73 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker98 body) Nothing (\inner -> fanWalker98 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 147; branches to fanWalker146, fanWalker74, fanWalker98.
+fanWalker147 :: Core.Term -> Maybe Core.Term
+fanWalker147 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker146 fun) (fanWalker146 arg) (\_ -> fanWalker146 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker74 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker98 body) Nothing (\inner -> fanWalker98 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 148; branches to fanWalker147, fanWalker74, fanWalker99.
+fanWalker148 :: Core.Term -> Maybe Core.Term
+fanWalker148 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker147 fun) (fanWalker147 arg) (\_ -> fanWalker147 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker74 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker99 body) Nothing (\inner -> fanWalker99 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 149; branches to fanWalker148, fanWalker75, fanWalker100.
+fanWalker149 :: Core.Term -> Maybe Core.Term
+fanWalker149 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker148 fun) (fanWalker148 arg) (\_ -> fanWalker148 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker75 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker100 body) Nothing (\inner -> fanWalker100 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 15; branches to fanWalker14, fanWalker8, fanWalker10.
+fanWalker15 :: Core.Term -> Maybe Core.Term
+fanWalker15 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker14 fun) (fanWalker14 arg) (\_ -> fanWalker14 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker8 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker10 body) Nothing (\inner -> fanWalker10 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 150; branches to fanWalker149, fanWalker75, fanWalker100.
+fanWalker150 :: Core.Term -> Maybe Core.Term
+fanWalker150 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker149 fun) (fanWalker149 arg) (\_ -> fanWalker149 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker75 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker100 body) Nothing (\inner -> fanWalker100 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 151; branches to fanWalker150, fanWalker76, fanWalker101.
+fanWalker151 :: Core.Term -> Maybe Core.Term
+fanWalker151 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker150 fun) (fanWalker150 arg) (\_ -> fanWalker150 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker76 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker101 body) Nothing (\inner -> fanWalker101 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 152; branches to fanWalker151, fanWalker76, fanWalker102.
+fanWalker152 :: Core.Term -> Maybe Core.Term
+fanWalker152 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker151 fun) (fanWalker151 arg) (\_ -> fanWalker151 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker76 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker102 body) Nothing (\inner -> fanWalker102 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 153; branches to fanWalker152, fanWalker77, fanWalker102.
+fanWalker153 :: Core.Term -> Maybe Core.Term
+fanWalker153 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker152 fun) (fanWalker152 arg) (\_ -> fanWalker152 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker77 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker102 body) Nothing (\inner -> fanWalker102 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 154; branches to fanWalker153, fanWalker77, fanWalker103.
+fanWalker154 :: Core.Term -> Maybe Core.Term
+fanWalker154 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker153 fun) (fanWalker153 arg) (\_ -> fanWalker153 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker77 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker103 body) Nothing (\inner -> fanWalker103 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 155; branches to fanWalker154, fanWalker78, fanWalker104.
+fanWalker155 :: Core.Term -> Maybe Core.Term
+fanWalker155 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker154 fun) (fanWalker154 arg) (\_ -> fanWalker154 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker78 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker104 body) Nothing (\inner -> fanWalker104 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 156; branches to fanWalker155, fanWalker78, fanWalker104.
+fanWalker156 :: Core.Term -> Maybe Core.Term
+fanWalker156 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker155 fun) (fanWalker155 arg) (\_ -> fanWalker155 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker78 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker104 body) Nothing (\inner -> fanWalker104 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 157; branches to fanWalker156, fanWalker79, fanWalker105.
+fanWalker157 :: Core.Term -> Maybe Core.Term
+fanWalker157 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker156 fun) (fanWalker156 arg) (\_ -> fanWalker156 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker79 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker105 body) Nothing (\inner -> fanWalker105 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 158; branches to fanWalker157, fanWalker79, fanWalker106.
+fanWalker158 :: Core.Term -> Maybe Core.Term
+fanWalker158 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker157 fun) (fanWalker157 arg) (\_ -> fanWalker157 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker79 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker106 body) Nothing (\inner -> fanWalker106 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 159; branches to fanWalker158, fanWalker80, fanWalker106.
+fanWalker159 :: Core.Term -> Maybe Core.Term
+fanWalker159 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker158 fun) (fanWalker158 arg) (\_ -> fanWalker158 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker80 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker106 body) Nothing (\inner -> fanWalker106 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 16; branches to fanWalker15, fanWalker8, fanWalker11.
+fanWalker16 :: Core.Term -> Maybe Core.Term
+fanWalker16 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker15 fun) (fanWalker15 arg) (\_ -> fanWalker15 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker8 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker11 body) Nothing (\inner -> fanWalker11 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 160; branches to fanWalker159, fanWalker80, fanWalker107.
+fanWalker160 :: Core.Term -> Maybe Core.Term
+fanWalker160 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker159 fun) (fanWalker159 arg) (\_ -> fanWalker159 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker80 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker107 body) Nothing (\inner -> fanWalker107 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 161; branches to fanWalker160, fanWalker81, fanWalker108.
+fanWalker161 :: Core.Term -> Maybe Core.Term
+fanWalker161 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker160 fun) (fanWalker160 arg) (\_ -> fanWalker160 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker81 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker108 body) Nothing (\inner -> fanWalker108 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 162; branches to fanWalker161, fanWalker81, fanWalker108.
+fanWalker162 :: Core.Term -> Maybe Core.Term
+fanWalker162 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker161 fun) (fanWalker161 arg) (\_ -> fanWalker161 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker81 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker108 body) Nothing (\inner -> fanWalker108 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 163; branches to fanWalker162, fanWalker82, fanWalker109.
+fanWalker163 :: Core.Term -> Maybe Core.Term
+fanWalker163 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker162 fun) (fanWalker162 arg) (\_ -> fanWalker162 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker82 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker109 body) Nothing (\inner -> fanWalker109 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 164; branches to fanWalker163, fanWalker82, fanWalker110.
+fanWalker164 :: Core.Term -> Maybe Core.Term
+fanWalker164 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker163 fun) (fanWalker163 arg) (\_ -> fanWalker163 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker82 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker110 body) Nothing (\inner -> fanWalker110 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 165; branches to fanWalker164, fanWalker83, fanWalker110.
+fanWalker165 :: Core.Term -> Maybe Core.Term
+fanWalker165 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker164 fun) (fanWalker164 arg) (\_ -> fanWalker164 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker83 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker110 body) Nothing (\inner -> fanWalker110 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 166; branches to fanWalker165, fanWalker83, fanWalker111.
+fanWalker166 :: Core.Term -> Maybe Core.Term
+fanWalker166 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker165 fun) (fanWalker165 arg) (\_ -> fanWalker165 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker83 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker111 body) Nothing (\inner -> fanWalker111 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 167; branches to fanWalker166, fanWalker84, fanWalker112.
+fanWalker167 :: Core.Term -> Maybe Core.Term
+fanWalker167 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker166 fun) (fanWalker166 arg) (\_ -> fanWalker166 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker84 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker112 body) Nothing (\inner -> fanWalker112 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 168; branches to fanWalker167, fanWalker84, fanWalker112.
+fanWalker168 :: Core.Term -> Maybe Core.Term
+fanWalker168 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker167 fun) (fanWalker167 arg) (\_ -> fanWalker167 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker84 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker112 body) Nothing (\inner -> fanWalker112 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 169; branches to fanWalker168, fanWalker85, fanWalker113.
+fanWalker169 :: Core.Term -> Maybe Core.Term
+fanWalker169 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker168 fun) (fanWalker168 arg) (\_ -> fanWalker168 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker85 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker113 body) Nothing (\inner -> fanWalker113 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 17; branches to fanWalker16, fanWalker9, fanWalker12.
+fanWalker17 :: Core.Term -> Maybe Core.Term
+fanWalker17 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker16 fun) (fanWalker16 arg) (\_ -> fanWalker16 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker9 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker12 body) Nothing (\inner -> fanWalker12 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 170; branches to fanWalker169, fanWalker85, fanWalker114.
+fanWalker170 :: Core.Term -> Maybe Core.Term
+fanWalker170 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker169 fun) (fanWalker169 arg) (\_ -> fanWalker169 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker85 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker114 body) Nothing (\inner -> fanWalker114 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 171; branches to fanWalker170, fanWalker86, fanWalker114.
+fanWalker171 :: Core.Term -> Maybe Core.Term
+fanWalker171 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker170 fun) (fanWalker170 arg) (\_ -> fanWalker170 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker86 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker114 body) Nothing (\inner -> fanWalker114 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 172; branches to fanWalker171, fanWalker86, fanWalker115.
+fanWalker172 :: Core.Term -> Maybe Core.Term
+fanWalker172 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker171 fun) (fanWalker171 arg) (\_ -> fanWalker171 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker86 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker115 body) Nothing (\inner -> fanWalker115 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 173; branches to fanWalker172, fanWalker87, fanWalker116.
+fanWalker173 :: Core.Term -> Maybe Core.Term
+fanWalker173 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker172 fun) (fanWalker172 arg) (\_ -> fanWalker172 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker87 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker116 body) Nothing (\inner -> fanWalker116 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 174; branches to fanWalker173, fanWalker87, fanWalker116.
+fanWalker174 :: Core.Term -> Maybe Core.Term
+fanWalker174 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker173 fun) (fanWalker173 arg) (\_ -> fanWalker173 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker87 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker116 body) Nothing (\inner -> fanWalker116 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 175; branches to fanWalker174, fanWalker88, fanWalker117.
+fanWalker175 :: Core.Term -> Maybe Core.Term
+fanWalker175 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker174 fun) (fanWalker174 arg) (\_ -> fanWalker174 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker88 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker117 body) Nothing (\inner -> fanWalker117 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 176; branches to fanWalker175, fanWalker88, fanWalker118.
+fanWalker176 :: Core.Term -> Maybe Core.Term
+fanWalker176 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker175 fun) (fanWalker175 arg) (\_ -> fanWalker175 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker88 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker118 body) Nothing (\inner -> fanWalker118 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 177; branches to fanWalker176, fanWalker89, fanWalker118.
+fanWalker177 :: Core.Term -> Maybe Core.Term
+fanWalker177 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker176 fun) (fanWalker176 arg) (\_ -> fanWalker176 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker89 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker118 body) Nothing (\inner -> fanWalker118 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 178; branches to fanWalker177, fanWalker89, fanWalker119.
+fanWalker178 :: Core.Term -> Maybe Core.Term
+fanWalker178 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker177 fun) (fanWalker177 arg) (\_ -> fanWalker177 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker89 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker119 body) Nothing (\inner -> fanWalker119 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 179; branches to fanWalker178, fanWalker90, fanWalker120.
+fanWalker179 :: Core.Term -> Maybe Core.Term
+fanWalker179 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker178 fun) (fanWalker178 arg) (\_ -> fanWalker178 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker90 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker120 body) Nothing (\inner -> fanWalker120 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 18; branches to fanWalker17, fanWalker9, fanWalker12.
+fanWalker18 :: Core.Term -> Maybe Core.Term
+fanWalker18 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker17 fun) (fanWalker17 arg) (\_ -> fanWalker17 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker9 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker12 body) Nothing (\inner -> fanWalker12 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 180; branches to fanWalker179, fanWalker90, fanWalker120.
+fanWalker180 :: Core.Term -> Maybe Core.Term
+fanWalker180 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker179 fun) (fanWalker179 arg) (\_ -> fanWalker179 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker90 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker120 body) Nothing (\inner -> fanWalker120 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 181; branches to fanWalker180, fanWalker91, fanWalker121.
+fanWalker181 :: Core.Term -> Maybe Core.Term
+fanWalker181 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker180 fun) (fanWalker180 arg) (\_ -> fanWalker180 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker91 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker121 body) Nothing (\inner -> fanWalker121 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 182; branches to fanWalker181, fanWalker91, fanWalker122.
+fanWalker182 :: Core.Term -> Maybe Core.Term
+fanWalker182 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker181 fun) (fanWalker181 arg) (\_ -> fanWalker181 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker91 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker122 body) Nothing (\inner -> fanWalker122 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 183; branches to fanWalker182, fanWalker92, fanWalker122.
+fanWalker183 :: Core.Term -> Maybe Core.Term
+fanWalker183 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker182 fun) (fanWalker182 arg) (\_ -> fanWalker182 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker92 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker122 body) Nothing (\inner -> fanWalker122 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 184; branches to fanWalker183, fanWalker92, fanWalker123.
+fanWalker184 :: Core.Term -> Maybe Core.Term
+fanWalker184 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker183 fun) (fanWalker183 arg) (\_ -> fanWalker183 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker92 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker123 body) Nothing (\inner -> fanWalker123 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 185; branches to fanWalker184, fanWalker93, fanWalker124.
+fanWalker185 :: Core.Term -> Maybe Core.Term
+fanWalker185 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker184 fun) (fanWalker184 arg) (\_ -> fanWalker184 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker93 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker124 body) Nothing (\inner -> fanWalker124 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 186; branches to fanWalker185, fanWalker93, fanWalker124.
+fanWalker186 :: Core.Term -> Maybe Core.Term
+fanWalker186 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker185 fun) (fanWalker185 arg) (\_ -> fanWalker185 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker93 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker124 body) Nothing (\inner -> fanWalker124 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 187; branches to fanWalker186, fanWalker94, fanWalker125.
+fanWalker187 :: Core.Term -> Maybe Core.Term
+fanWalker187 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker186 fun) (fanWalker186 arg) (\_ -> fanWalker186 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker94 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker125 body) Nothing (\inner -> fanWalker125 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 188; branches to fanWalker187, fanWalker94, fanWalker126.
+fanWalker188 :: Core.Term -> Maybe Core.Term
+fanWalker188 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker187 fun) (fanWalker187 arg) (\_ -> fanWalker187 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker94 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker126 body) Nothing (\inner -> fanWalker126 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 189; branches to fanWalker188, fanWalker95, fanWalker126.
+fanWalker189 :: Core.Term -> Maybe Core.Term
+fanWalker189 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker188 fun) (fanWalker188 arg) (\_ -> fanWalker188 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker95 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker126 body) Nothing (\inner -> fanWalker126 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 19; branches to fanWalker18, fanWalker10, fanWalker13.
+fanWalker19 :: Core.Term -> Maybe Core.Term
+fanWalker19 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker18 fun) (fanWalker18 arg) (\_ -> fanWalker18 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker10 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker13 body) Nothing (\inner -> fanWalker13 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 190; branches to fanWalker189, fanWalker95, fanWalker127.
+fanWalker190 :: Core.Term -> Maybe Core.Term
+fanWalker190 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker189 fun) (fanWalker189 arg) (\_ -> fanWalker189 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker95 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker127 body) Nothing (\inner -> fanWalker127 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 191; branches to fanWalker190, fanWalker96, fanWalker128.
+fanWalker191 :: Core.Term -> Maybe Core.Term
+fanWalker191 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker190 fun) (fanWalker190 arg) (\_ -> fanWalker190 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker96 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker128 body) Nothing (\inner -> fanWalker128 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 192; branches to fanWalker191, fanWalker96, fanWalker128.
+fanWalker192 :: Core.Term -> Maybe Core.Term
+fanWalker192 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker191 fun) (fanWalker191 arg) (\_ -> fanWalker191 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker96 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker128 body) Nothing (\inner -> fanWalker128 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 193; branches to fanWalker192, fanWalker97, fanWalker129.
+fanWalker193 :: Core.Term -> Maybe Core.Term
+fanWalker193 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker192 fun) (fanWalker192 arg) (\_ -> fanWalker192 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker97 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker129 body) Nothing (\inner -> fanWalker129 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 194; branches to fanWalker193, fanWalker97, fanWalker130.
+fanWalker194 :: Core.Term -> Maybe Core.Term
+fanWalker194 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker193 fun) (fanWalker193 arg) (\_ -> fanWalker193 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker97 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker130 body) Nothing (\inner -> fanWalker130 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 195; branches to fanWalker194, fanWalker98, fanWalker130.
+fanWalker195 :: Core.Term -> Maybe Core.Term
+fanWalker195 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker194 fun) (fanWalker194 arg) (\_ -> fanWalker194 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker98 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker130 body) Nothing (\inner -> fanWalker130 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 196; branches to fanWalker195, fanWalker98, fanWalker131.
+fanWalker196 :: Core.Term -> Maybe Core.Term
+fanWalker196 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker195 fun) (fanWalker195 arg) (\_ -> fanWalker195 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker98 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker131 body) Nothing (\inner -> fanWalker131 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 197; branches to fanWalker196, fanWalker99, fanWalker132.
+fanWalker197 :: Core.Term -> Maybe Core.Term
+fanWalker197 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker196 fun) (fanWalker196 arg) (\_ -> fanWalker196 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker99 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker132 body) Nothing (\inner -> fanWalker132 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 198; branches to fanWalker197, fanWalker99, fanWalker132.
+fanWalker198 :: Core.Term -> Maybe Core.Term
+fanWalker198 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker197 fun) (fanWalker197 arg) (\_ -> fanWalker197 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker99 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker132 body) Nothing (\inner -> fanWalker132 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 199; branches to fanWalker198, fanWalker100, fanWalker133.
+fanWalker199 :: Core.Term -> Maybe Core.Term
+fanWalker199 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker198 fun) (fanWalker198 arg) (\_ -> fanWalker198 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker100 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker133 body) Nothing (\inner -> fanWalker133 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 2; branches to fanWalker1, fanWalker1, fanWalker1.
+fanWalker2 :: Core.Term -> Maybe Core.Term
+fanWalker2 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker1 fun) (fanWalker1 arg) (\_ -> fanWalker1 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker1 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker1 body) Nothing (\inner -> fanWalker1 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 20; branches to fanWalker19, fanWalker10, fanWalker14.
+fanWalker20 :: Core.Term -> Maybe Core.Term
+fanWalker20 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker19 fun) (fanWalker19 arg) (\_ -> fanWalker19 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker10 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker14 body) Nothing (\inner -> fanWalker14 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 200; branches to fanWalker199, fanWalker100, fanWalker134.
+fanWalker200 :: Core.Term -> Maybe Core.Term
+fanWalker200 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker199 fun) (fanWalker199 arg) (\_ -> fanWalker199 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker100 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker134 body) Nothing (\inner -> fanWalker134 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 201; branches to fanWalker200, fanWalker101, fanWalker134.
+fanWalker201 :: Core.Term -> Maybe Core.Term
+fanWalker201 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker200 fun) (fanWalker200 arg) (\_ -> fanWalker200 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker101 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker134 body) Nothing (\inner -> fanWalker134 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 202; branches to fanWalker201, fanWalker101, fanWalker135.
+fanWalker202 :: Core.Term -> Maybe Core.Term
+fanWalker202 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker201 fun) (fanWalker201 arg) (\_ -> fanWalker201 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker101 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker135 body) Nothing (\inner -> fanWalker135 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 203; branches to fanWalker202, fanWalker102, fanWalker136.
+fanWalker203 :: Core.Term -> Maybe Core.Term
+fanWalker203 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker202 fun) (fanWalker202 arg) (\_ -> fanWalker202 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker102 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker136 body) Nothing (\inner -> fanWalker136 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 204; branches to fanWalker203, fanWalker102, fanWalker136.
+fanWalker204 :: Core.Term -> Maybe Core.Term
+fanWalker204 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker203 fun) (fanWalker203 arg) (\_ -> fanWalker203 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker102 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker136 body) Nothing (\inner -> fanWalker136 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 205; branches to fanWalker204, fanWalker103, fanWalker137.
+fanWalker205 :: Core.Term -> Maybe Core.Term
+fanWalker205 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker204 fun) (fanWalker204 arg) (\_ -> fanWalker204 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker103 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker137 body) Nothing (\inner -> fanWalker137 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 206; branches to fanWalker205, fanWalker103, fanWalker138.
+fanWalker206 :: Core.Term -> Maybe Core.Term
+fanWalker206 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker205 fun) (fanWalker205 arg) (\_ -> fanWalker205 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker103 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker138 body) Nothing (\inner -> fanWalker138 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 207; branches to fanWalker206, fanWalker104, fanWalker138.
+fanWalker207 :: Core.Term -> Maybe Core.Term
+fanWalker207 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker206 fun) (fanWalker206 arg) (\_ -> fanWalker206 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker104 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker138 body) Nothing (\inner -> fanWalker138 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 208; branches to fanWalker207, fanWalker104, fanWalker139.
+fanWalker208 :: Core.Term -> Maybe Core.Term
+fanWalker208 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker207 fun) (fanWalker207 arg) (\_ -> fanWalker207 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker104 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker139 body) Nothing (\inner -> fanWalker139 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 209; branches to fanWalker208, fanWalker105, fanWalker140.
+fanWalker209 :: Core.Term -> Maybe Core.Term
+fanWalker209 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker208 fun) (fanWalker208 arg) (\_ -> fanWalker208 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker105 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker140 body) Nothing (\inner -> fanWalker140 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 21; branches to fanWalker20, fanWalker11, fanWalker14.
+fanWalker21 :: Core.Term -> Maybe Core.Term
+fanWalker21 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker20 fun) (fanWalker20 arg) (\_ -> fanWalker20 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker11 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker14 body) Nothing (\inner -> fanWalker14 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 210; branches to fanWalker209, fanWalker105, fanWalker140.
+fanWalker210 :: Core.Term -> Maybe Core.Term
+fanWalker210 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker209 fun) (fanWalker209 arg) (\_ -> fanWalker209 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker105 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker140 body) Nothing (\inner -> fanWalker140 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 211; branches to fanWalker210, fanWalker106, fanWalker141.
+fanWalker211 :: Core.Term -> Maybe Core.Term
+fanWalker211 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker210 fun) (fanWalker210 arg) (\_ -> fanWalker210 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker106 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker141 body) Nothing (\inner -> fanWalker141 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 212; branches to fanWalker211, fanWalker106, fanWalker142.
+fanWalker212 :: Core.Term -> Maybe Core.Term
+fanWalker212 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker211 fun) (fanWalker211 arg) (\_ -> fanWalker211 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker106 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker142 body) Nothing (\inner -> fanWalker142 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 213; branches to fanWalker212, fanWalker107, fanWalker142.
+fanWalker213 :: Core.Term -> Maybe Core.Term
+fanWalker213 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker212 fun) (fanWalker212 arg) (\_ -> fanWalker212 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker107 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker142 body) Nothing (\inner -> fanWalker142 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 214; branches to fanWalker213, fanWalker107, fanWalker143.
+fanWalker214 :: Core.Term -> Maybe Core.Term
+fanWalker214 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker213 fun) (fanWalker213 arg) (\_ -> fanWalker213 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker107 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker143 body) Nothing (\inner -> fanWalker143 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 215; branches to fanWalker214, fanWalker108, fanWalker144.
+fanWalker215 :: Core.Term -> Maybe Core.Term
+fanWalker215 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker214 fun) (fanWalker214 arg) (\_ -> fanWalker214 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker108 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker144 body) Nothing (\inner -> fanWalker144 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 216; branches to fanWalker215, fanWalker108, fanWalker144.
+fanWalker216 :: Core.Term -> Maybe Core.Term
+fanWalker216 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker215 fun) (fanWalker215 arg) (\_ -> fanWalker215 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker108 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker144 body) Nothing (\inner -> fanWalker144 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 217; branches to fanWalker216, fanWalker109, fanWalker145.
+fanWalker217 :: Core.Term -> Maybe Core.Term
+fanWalker217 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker216 fun) (fanWalker216 arg) (\_ -> fanWalker216 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker109 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker145 body) Nothing (\inner -> fanWalker145 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 218; branches to fanWalker217, fanWalker109, fanWalker146.
+fanWalker218 :: Core.Term -> Maybe Core.Term
+fanWalker218 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker217 fun) (fanWalker217 arg) (\_ -> fanWalker217 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker109 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker146 body) Nothing (\inner -> fanWalker146 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 219; branches to fanWalker218, fanWalker110, fanWalker146.
+fanWalker219 :: Core.Term -> Maybe Core.Term
+fanWalker219 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker218 fun) (fanWalker218 arg) (\_ -> fanWalker218 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker110 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker146 body) Nothing (\inner -> fanWalker146 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 22; branches to fanWalker21, fanWalker11, fanWalker15.
+fanWalker22 :: Core.Term -> Maybe Core.Term
+fanWalker22 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker21 fun) (fanWalker21 arg) (\_ -> fanWalker21 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker11 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker15 body) Nothing (\inner -> fanWalker15 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 220; branches to fanWalker219, fanWalker110, fanWalker147.
+fanWalker220 :: Core.Term -> Maybe Core.Term
+fanWalker220 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker219 fun) (fanWalker219 arg) (\_ -> fanWalker219 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker110 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker147 body) Nothing (\inner -> fanWalker147 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 221; branches to fanWalker220, fanWalker111, fanWalker148.
+fanWalker221 :: Core.Term -> Maybe Core.Term
+fanWalker221 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker220 fun) (fanWalker220 arg) (\_ -> fanWalker220 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker111 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker148 body) Nothing (\inner -> fanWalker148 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 222; branches to fanWalker221, fanWalker111, fanWalker148.
+fanWalker222 :: Core.Term -> Maybe Core.Term
+fanWalker222 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker221 fun) (fanWalker221 arg) (\_ -> fanWalker221 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker111 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker148 body) Nothing (\inner -> fanWalker148 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 223; branches to fanWalker222, fanWalker112, fanWalker149.
+fanWalker223 :: Core.Term -> Maybe Core.Term
+fanWalker223 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker222 fun) (fanWalker222 arg) (\_ -> fanWalker222 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker112 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker149 body) Nothing (\inner -> fanWalker149 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 224; branches to fanWalker223, fanWalker112, fanWalker150.
+fanWalker224 :: Core.Term -> Maybe Core.Term
+fanWalker224 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker223 fun) (fanWalker223 arg) (\_ -> fanWalker223 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker112 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker150 body) Nothing (\inner -> fanWalker150 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 225; branches to fanWalker224, fanWalker113, fanWalker150.
+fanWalker225 :: Core.Term -> Maybe Core.Term
+fanWalker225 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker224 fun) (fanWalker224 arg) (\_ -> fanWalker224 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker113 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker150 body) Nothing (\inner -> fanWalker150 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 226; branches to fanWalker225, fanWalker113, fanWalker151.
+fanWalker226 :: Core.Term -> Maybe Core.Term
+fanWalker226 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker225 fun) (fanWalker225 arg) (\_ -> fanWalker225 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker113 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker151 body) Nothing (\inner -> fanWalker151 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 227; branches to fanWalker226, fanWalker114, fanWalker152.
+fanWalker227 :: Core.Term -> Maybe Core.Term
+fanWalker227 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker226 fun) (fanWalker226 arg) (\_ -> fanWalker226 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker114 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker152 body) Nothing (\inner -> fanWalker152 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 228; branches to fanWalker227, fanWalker114, fanWalker152.
+fanWalker228 :: Core.Term -> Maybe Core.Term
+fanWalker228 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker227 fun) (fanWalker227 arg) (\_ -> fanWalker227 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker114 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker152 body) Nothing (\inner -> fanWalker152 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 229; branches to fanWalker228, fanWalker115, fanWalker153.
+fanWalker229 :: Core.Term -> Maybe Core.Term
+fanWalker229 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker228 fun) (fanWalker228 arg) (\_ -> fanWalker228 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker115 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker153 body) Nothing (\inner -> fanWalker153 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 23; branches to fanWalker22, fanWalker12, fanWalker16.
+fanWalker23 :: Core.Term -> Maybe Core.Term
+fanWalker23 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker22 fun) (fanWalker22 arg) (\_ -> fanWalker22 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker12 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker16 body) Nothing (\inner -> fanWalker16 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 230; branches to fanWalker229, fanWalker115, fanWalker154.
+fanWalker230 :: Core.Term -> Maybe Core.Term
+fanWalker230 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker229 fun) (fanWalker229 arg) (\_ -> fanWalker229 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker115 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker154 body) Nothing (\inner -> fanWalker154 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 231; branches to fanWalker230, fanWalker116, fanWalker154.
+fanWalker231 :: Core.Term -> Maybe Core.Term
+fanWalker231 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker230 fun) (fanWalker230 arg) (\_ -> fanWalker230 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker116 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker154 body) Nothing (\inner -> fanWalker154 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 232; branches to fanWalker231, fanWalker116, fanWalker155.
+fanWalker232 :: Core.Term -> Maybe Core.Term
+fanWalker232 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker231 fun) (fanWalker231 arg) (\_ -> fanWalker231 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker116 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker155 body) Nothing (\inner -> fanWalker155 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 233; branches to fanWalker232, fanWalker117, fanWalker156.
+fanWalker233 :: Core.Term -> Maybe Core.Term
+fanWalker233 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker232 fun) (fanWalker232 arg) (\_ -> fanWalker232 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker117 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker156 body) Nothing (\inner -> fanWalker156 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 234; branches to fanWalker233, fanWalker117, fanWalker156.
+fanWalker234 :: Core.Term -> Maybe Core.Term
+fanWalker234 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker233 fun) (fanWalker233 arg) (\_ -> fanWalker233 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker117 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker156 body) Nothing (\inner -> fanWalker156 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 235; branches to fanWalker234, fanWalker118, fanWalker157.
+fanWalker235 :: Core.Term -> Maybe Core.Term
+fanWalker235 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker234 fun) (fanWalker234 arg) (\_ -> fanWalker234 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker118 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker157 body) Nothing (\inner -> fanWalker157 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 236; branches to fanWalker235, fanWalker118, fanWalker158.
+fanWalker236 :: Core.Term -> Maybe Core.Term
+fanWalker236 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker235 fun) (fanWalker235 arg) (\_ -> fanWalker235 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker118 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker158 body) Nothing (\inner -> fanWalker158 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 237; branches to fanWalker236, fanWalker119, fanWalker158.
+fanWalker237 :: Core.Term -> Maybe Core.Term
+fanWalker237 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker236 fun) (fanWalker236 arg) (\_ -> fanWalker236 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker119 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker158 body) Nothing (\inner -> fanWalker158 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 238; branches to fanWalker237, fanWalker119, fanWalker159.
+fanWalker238 :: Core.Term -> Maybe Core.Term
+fanWalker238 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker237 fun) (fanWalker237 arg) (\_ -> fanWalker237 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker119 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker159 body) Nothing (\inner -> fanWalker159 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 239; branches to fanWalker238, fanWalker120, fanWalker160.
+fanWalker239 :: Core.Term -> Maybe Core.Term
+fanWalker239 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker238 fun) (fanWalker238 arg) (\_ -> fanWalker238 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker120 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker160 body) Nothing (\inner -> fanWalker160 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 24; branches to fanWalker23, fanWalker12, fanWalker16.
+fanWalker24 :: Core.Term -> Maybe Core.Term
+fanWalker24 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker23 fun) (fanWalker23 arg) (\_ -> fanWalker23 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker12 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker16 body) Nothing (\inner -> fanWalker16 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 240; branches to fanWalker239, fanWalker120, fanWalker160.
+fanWalker240 :: Core.Term -> Maybe Core.Term
+fanWalker240 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker239 fun) (fanWalker239 arg) (\_ -> fanWalker239 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker120 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker160 body) Nothing (\inner -> fanWalker160 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 241; branches to fanWalker240, fanWalker121, fanWalker161.
+fanWalker241 :: Core.Term -> Maybe Core.Term
+fanWalker241 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker240 fun) (fanWalker240 arg) (\_ -> fanWalker240 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker121 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker161 body) Nothing (\inner -> fanWalker161 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 242; branches to fanWalker241, fanWalker121, fanWalker162.
+fanWalker242 :: Core.Term -> Maybe Core.Term
+fanWalker242 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker241 fun) (fanWalker241 arg) (\_ -> fanWalker241 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker121 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker162 body) Nothing (\inner -> fanWalker162 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 243; branches to fanWalker242, fanWalker122, fanWalker162.
+fanWalker243 :: Core.Term -> Maybe Core.Term
+fanWalker243 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker242 fun) (fanWalker242 arg) (\_ -> fanWalker242 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker122 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker162 body) Nothing (\inner -> fanWalker162 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 244; branches to fanWalker243, fanWalker122, fanWalker163.
+fanWalker244 :: Core.Term -> Maybe Core.Term
+fanWalker244 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker243 fun) (fanWalker243 arg) (\_ -> fanWalker243 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker122 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker163 body) Nothing (\inner -> fanWalker163 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 245; branches to fanWalker244, fanWalker123, fanWalker164.
+fanWalker245 :: Core.Term -> Maybe Core.Term
+fanWalker245 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker244 fun) (fanWalker244 arg) (\_ -> fanWalker244 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker123 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker164 body) Nothing (\inner -> fanWalker164 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 246; branches to fanWalker245, fanWalker123, fanWalker164.
+fanWalker246 :: Core.Term -> Maybe Core.Term
+fanWalker246 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker245 fun) (fanWalker245 arg) (\_ -> fanWalker245 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker123 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker164 body) Nothing (\inner -> fanWalker164 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 247; branches to fanWalker246, fanWalker124, fanWalker165.
+fanWalker247 :: Core.Term -> Maybe Core.Term
+fanWalker247 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker246 fun) (fanWalker246 arg) (\_ -> fanWalker246 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker124 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker165 body) Nothing (\inner -> fanWalker165 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 248; branches to fanWalker247, fanWalker124, fanWalker166.
+fanWalker248 :: Core.Term -> Maybe Core.Term
+fanWalker248 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker247 fun) (fanWalker247 arg) (\_ -> fanWalker247 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker124 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker166 body) Nothing (\inner -> fanWalker166 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 249; branches to fanWalker248, fanWalker125, fanWalker166.
+fanWalker249 :: Core.Term -> Maybe Core.Term
+fanWalker249 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker248 fun) (fanWalker248 arg) (\_ -> fanWalker248 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker125 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker166 body) Nothing (\inner -> fanWalker166 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 25; branches to fanWalker24, fanWalker13, fanWalker17.
+fanWalker25 :: Core.Term -> Maybe Core.Term
+fanWalker25 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker24 fun) (fanWalker24 arg) (\_ -> fanWalker24 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker13 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker17 body) Nothing (\inner -> fanWalker17 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 250; branches to fanWalker249, fanWalker125, fanWalker167.
+fanWalker250 :: Core.Term -> Maybe Core.Term
+fanWalker250 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker249 fun) (fanWalker249 arg) (\_ -> fanWalker249 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker125 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker167 body) Nothing (\inner -> fanWalker167 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 251; branches to fanWalker250, fanWalker126, fanWalker168.
+fanWalker251 :: Core.Term -> Maybe Core.Term
+fanWalker251 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker250 fun) (fanWalker250 arg) (\_ -> fanWalker250 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker126 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker168 body) Nothing (\inner -> fanWalker168 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 252; branches to fanWalker251, fanWalker126, fanWalker168.
+fanWalker252 :: Core.Term -> Maybe Core.Term
+fanWalker252 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker251 fun) (fanWalker251 arg) (\_ -> fanWalker251 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker126 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker168 body) Nothing (\inner -> fanWalker168 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 253; branches to fanWalker252, fanWalker127, fanWalker169.
+fanWalker253 :: Core.Term -> Maybe Core.Term
+fanWalker253 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker252 fun) (fanWalker252 arg) (\_ -> fanWalker252 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker127 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker169 body) Nothing (\inner -> fanWalker169 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 254; branches to fanWalker253, fanWalker127, fanWalker170.
+fanWalker254 :: Core.Term -> Maybe Core.Term
+fanWalker254 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker253 fun) (fanWalker253 arg) (\_ -> fanWalker253 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker127 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker170 body) Nothing (\inner -> fanWalker170 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 255; branches to fanWalker254, fanWalker128, fanWalker170.
+fanWalker255 :: Core.Term -> Maybe Core.Term
+fanWalker255 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker254 fun) (fanWalker254 arg) (\_ -> fanWalker254 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker128 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker170 body) Nothing (\inner -> fanWalker170 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 256; branches to fanWalker255, fanWalker128, fanWalker171.
+fanWalker256 :: Core.Term -> Maybe Core.Term
+fanWalker256 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker255 fun) (fanWalker255 arg) (\_ -> fanWalker255 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker128 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker171 body) Nothing (\inner -> fanWalker171 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 257; branches to fanWalker256, fanWalker129, fanWalker172.
+fanWalker257 :: Core.Term -> Maybe Core.Term
+fanWalker257 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker256 fun) (fanWalker256 arg) (\_ -> fanWalker256 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker129 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker172 body) Nothing (\inner -> fanWalker172 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 258; branches to fanWalker257, fanWalker129, fanWalker172.
+fanWalker258 :: Core.Term -> Maybe Core.Term
+fanWalker258 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker257 fun) (fanWalker257 arg) (\_ -> fanWalker257 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker129 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker172 body) Nothing (\inner -> fanWalker172 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 259; branches to fanWalker258, fanWalker130, fanWalker173.
+fanWalker259 :: Core.Term -> Maybe Core.Term
+fanWalker259 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker258 fun) (fanWalker258 arg) (\_ -> fanWalker258 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker130 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker173 body) Nothing (\inner -> fanWalker173 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 26; branches to fanWalker25, fanWalker13, fanWalker18.
+fanWalker26 :: Core.Term -> Maybe Core.Term
+fanWalker26 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker25 fun) (fanWalker25 arg) (\_ -> fanWalker25 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker13 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker18 body) Nothing (\inner -> fanWalker18 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 260; branches to fanWalker259, fanWalker130, fanWalker174.
+fanWalker260 :: Core.Term -> Maybe Core.Term
+fanWalker260 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker259 fun) (fanWalker259 arg) (\_ -> fanWalker259 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker130 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker174 body) Nothing (\inner -> fanWalker174 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 261; branches to fanWalker260, fanWalker131, fanWalker174.
+fanWalker261 :: Core.Term -> Maybe Core.Term
+fanWalker261 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker260 fun) (fanWalker260 arg) (\_ -> fanWalker260 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker131 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker174 body) Nothing (\inner -> fanWalker174 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 262; branches to fanWalker261, fanWalker131, fanWalker175.
+fanWalker262 :: Core.Term -> Maybe Core.Term
+fanWalker262 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker261 fun) (fanWalker261 arg) (\_ -> fanWalker261 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker131 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker175 body) Nothing (\inner -> fanWalker175 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 263; branches to fanWalker262, fanWalker132, fanWalker176.
+fanWalker263 :: Core.Term -> Maybe Core.Term
+fanWalker263 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker262 fun) (fanWalker262 arg) (\_ -> fanWalker262 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker132 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker176 body) Nothing (\inner -> fanWalker176 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 264; branches to fanWalker263, fanWalker132, fanWalker176.
+fanWalker264 :: Core.Term -> Maybe Core.Term
+fanWalker264 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker263 fun) (fanWalker263 arg) (\_ -> fanWalker263 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker132 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker176 body) Nothing (\inner -> fanWalker176 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 265; branches to fanWalker264, fanWalker133, fanWalker177.
+fanWalker265 :: Core.Term -> Maybe Core.Term
+fanWalker265 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker264 fun) (fanWalker264 arg) (\_ -> fanWalker264 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker133 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker177 body) Nothing (\inner -> fanWalker177 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 266; branches to fanWalker265, fanWalker133, fanWalker178.
+fanWalker266 :: Core.Term -> Maybe Core.Term
+fanWalker266 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker265 fun) (fanWalker265 arg) (\_ -> fanWalker265 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker133 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker178 body) Nothing (\inner -> fanWalker178 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 267; branches to fanWalker266, fanWalker134, fanWalker178.
+fanWalker267 :: Core.Term -> Maybe Core.Term
+fanWalker267 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker266 fun) (fanWalker266 arg) (\_ -> fanWalker266 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker134 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker178 body) Nothing (\inner -> fanWalker178 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 268; branches to fanWalker267, fanWalker134, fanWalker179.
+fanWalker268 :: Core.Term -> Maybe Core.Term
+fanWalker268 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker267 fun) (fanWalker267 arg) (\_ -> fanWalker267 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker134 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker179 body) Nothing (\inner -> fanWalker179 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 269; branches to fanWalker268, fanWalker135, fanWalker180.
+fanWalker269 :: Core.Term -> Maybe Core.Term
+fanWalker269 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker268 fun) (fanWalker268 arg) (\_ -> fanWalker268 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker135 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker180 body) Nothing (\inner -> fanWalker180 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 27; branches to fanWalker26, fanWalker14, fanWalker18.
+fanWalker27 :: Core.Term -> Maybe Core.Term
+fanWalker27 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker26 fun) (fanWalker26 arg) (\_ -> fanWalker26 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker14 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker18 body) Nothing (\inner -> fanWalker18 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 270; branches to fanWalker269, fanWalker135, fanWalker180.
+fanWalker270 :: Core.Term -> Maybe Core.Term
+fanWalker270 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker269 fun) (fanWalker269 arg) (\_ -> fanWalker269 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker135 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker180 body) Nothing (\inner -> fanWalker180 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 271; branches to fanWalker270, fanWalker136, fanWalker181.
+fanWalker271 :: Core.Term -> Maybe Core.Term
+fanWalker271 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker270 fun) (fanWalker270 arg) (\_ -> fanWalker270 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker136 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker181 body) Nothing (\inner -> fanWalker181 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 272; branches to fanWalker271, fanWalker136, fanWalker182.
+fanWalker272 :: Core.Term -> Maybe Core.Term
+fanWalker272 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker271 fun) (fanWalker271 arg) (\_ -> fanWalker271 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker136 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker182 body) Nothing (\inner -> fanWalker182 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 273; branches to fanWalker272, fanWalker137, fanWalker182.
+fanWalker273 :: Core.Term -> Maybe Core.Term
+fanWalker273 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker272 fun) (fanWalker272 arg) (\_ -> fanWalker272 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker137 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker182 body) Nothing (\inner -> fanWalker182 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 274; branches to fanWalker273, fanWalker137, fanWalker183.
+fanWalker274 :: Core.Term -> Maybe Core.Term
+fanWalker274 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker273 fun) (fanWalker273 arg) (\_ -> fanWalker273 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker137 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker183 body) Nothing (\inner -> fanWalker183 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 275; branches to fanWalker274, fanWalker138, fanWalker184.
+fanWalker275 :: Core.Term -> Maybe Core.Term
+fanWalker275 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker274 fun) (fanWalker274 arg) (\_ -> fanWalker274 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker138 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker184 body) Nothing (\inner -> fanWalker184 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 276; branches to fanWalker275, fanWalker138, fanWalker184.
+fanWalker276 :: Core.Term -> Maybe Core.Term
+fanWalker276 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker275 fun) (fanWalker275 arg) (\_ -> fanWalker275 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker138 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker184 body) Nothing (\inner -> fanWalker184 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 277; branches to fanWalker276, fanWalker139, fanWalker185.
+fanWalker277 :: Core.Term -> Maybe Core.Term
+fanWalker277 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker276 fun) (fanWalker276 arg) (\_ -> fanWalker276 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker139 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker185 body) Nothing (\inner -> fanWalker185 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 278; branches to fanWalker277, fanWalker139, fanWalker186.
+fanWalker278 :: Core.Term -> Maybe Core.Term
+fanWalker278 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker277 fun) (fanWalker277 arg) (\_ -> fanWalker277 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker139 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker186 body) Nothing (\inner -> fanWalker186 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 279; branches to fanWalker278, fanWalker140, fanWalker186.
+fanWalker279 :: Core.Term -> Maybe Core.Term
+fanWalker279 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker278 fun) (fanWalker278 arg) (\_ -> fanWalker278 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker140 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker186 body) Nothing (\inner -> fanWalker186 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 28; branches to fanWalker27, fanWalker14, fanWalker19.
+fanWalker28 :: Core.Term -> Maybe Core.Term
+fanWalker28 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker27 fun) (fanWalker27 arg) (\_ -> fanWalker27 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker14 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker19 body) Nothing (\inner -> fanWalker19 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 280; branches to fanWalker279, fanWalker140, fanWalker187.
+fanWalker280 :: Core.Term -> Maybe Core.Term
+fanWalker280 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker279 fun) (fanWalker279 arg) (\_ -> fanWalker279 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker140 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker187 body) Nothing (\inner -> fanWalker187 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 281; branches to fanWalker280, fanWalker141, fanWalker188.
+fanWalker281 :: Core.Term -> Maybe Core.Term
+fanWalker281 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker280 fun) (fanWalker280 arg) (\_ -> fanWalker280 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker141 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker188 body) Nothing (\inner -> fanWalker188 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 282; branches to fanWalker281, fanWalker141, fanWalker188.
+fanWalker282 :: Core.Term -> Maybe Core.Term
+fanWalker282 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker281 fun) (fanWalker281 arg) (\_ -> fanWalker281 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker141 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker188 body) Nothing (\inner -> fanWalker188 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 283; branches to fanWalker282, fanWalker142, fanWalker189.
+fanWalker283 :: Core.Term -> Maybe Core.Term
+fanWalker283 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker282 fun) (fanWalker282 arg) (\_ -> fanWalker282 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker142 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker189 body) Nothing (\inner -> fanWalker189 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 284; branches to fanWalker283, fanWalker142, fanWalker190.
+fanWalker284 :: Core.Term -> Maybe Core.Term
+fanWalker284 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker283 fun) (fanWalker283 arg) (\_ -> fanWalker283 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker142 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker190 body) Nothing (\inner -> fanWalker190 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 285; branches to fanWalker284, fanWalker143, fanWalker190.
+fanWalker285 :: Core.Term -> Maybe Core.Term
+fanWalker285 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker284 fun) (fanWalker284 arg) (\_ -> fanWalker284 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker143 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker190 body) Nothing (\inner -> fanWalker190 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 286; branches to fanWalker285, fanWalker143, fanWalker191.
+fanWalker286 :: Core.Term -> Maybe Core.Term
+fanWalker286 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker285 fun) (fanWalker285 arg) (\_ -> fanWalker285 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker143 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker191 body) Nothing (\inner -> fanWalker191 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 287; branches to fanWalker286, fanWalker144, fanWalker192.
+fanWalker287 :: Core.Term -> Maybe Core.Term
+fanWalker287 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker286 fun) (fanWalker286 arg) (\_ -> fanWalker286 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker144 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker192 body) Nothing (\inner -> fanWalker192 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 288; branches to fanWalker287, fanWalker144, fanWalker192.
+fanWalker288 :: Core.Term -> Maybe Core.Term
+fanWalker288 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker287 fun) (fanWalker287 arg) (\_ -> fanWalker287 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker144 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker192 body) Nothing (\inner -> fanWalker192 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 289; branches to fanWalker288, fanWalker145, fanWalker193.
+fanWalker289 :: Core.Term -> Maybe Core.Term
+fanWalker289 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker288 fun) (fanWalker288 arg) (\_ -> fanWalker288 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker145 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker193 body) Nothing (\inner -> fanWalker193 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 29; branches to fanWalker28, fanWalker15, fanWalker20.
+fanWalker29 :: Core.Term -> Maybe Core.Term
+fanWalker29 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker28 fun) (fanWalker28 arg) (\_ -> fanWalker28 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker15 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker20 body) Nothing (\inner -> fanWalker20 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 290; branches to fanWalker289, fanWalker145, fanWalker194.
+fanWalker290 :: Core.Term -> Maybe Core.Term
+fanWalker290 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker289 fun) (fanWalker289 arg) (\_ -> fanWalker289 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker145 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker194 body) Nothing (\inner -> fanWalker194 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 291; branches to fanWalker290, fanWalker146, fanWalker194.
+fanWalker291 :: Core.Term -> Maybe Core.Term
+fanWalker291 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker290 fun) (fanWalker290 arg) (\_ -> fanWalker290 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker146 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker194 body) Nothing (\inner -> fanWalker194 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 292; branches to fanWalker291, fanWalker146, fanWalker195.
+fanWalker292 :: Core.Term -> Maybe Core.Term
+fanWalker292 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker291 fun) (fanWalker291 arg) (\_ -> fanWalker291 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker146 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker195 body) Nothing (\inner -> fanWalker195 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 293; branches to fanWalker292, fanWalker147, fanWalker196.
+fanWalker293 :: Core.Term -> Maybe Core.Term
+fanWalker293 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker292 fun) (fanWalker292 arg) (\_ -> fanWalker292 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker147 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker196 body) Nothing (\inner -> fanWalker196 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 294; branches to fanWalker293, fanWalker147, fanWalker196.
+fanWalker294 :: Core.Term -> Maybe Core.Term
+fanWalker294 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker293 fun) (fanWalker293 arg) (\_ -> fanWalker293 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker147 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker196 body) Nothing (\inner -> fanWalker196 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 295; branches to fanWalker294, fanWalker148, fanWalker197.
+fanWalker295 :: Core.Term -> Maybe Core.Term
+fanWalker295 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker294 fun) (fanWalker294 arg) (\_ -> fanWalker294 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker148 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker197 body) Nothing (\inner -> fanWalker197 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 296; branches to fanWalker295, fanWalker148, fanWalker198.
+fanWalker296 :: Core.Term -> Maybe Core.Term
+fanWalker296 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker295 fun) (fanWalker295 arg) (\_ -> fanWalker295 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker148 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker198 body) Nothing (\inner -> fanWalker198 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 297; branches to fanWalker296, fanWalker149, fanWalker198.
+fanWalker297 :: Core.Term -> Maybe Core.Term
+fanWalker297 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker296 fun) (fanWalker296 arg) (\_ -> fanWalker296 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker149 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker198 body) Nothing (\inner -> fanWalker198 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 298; branches to fanWalker297, fanWalker149, fanWalker199.
+fanWalker298 :: Core.Term -> Maybe Core.Term
+fanWalker298 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker297 fun) (fanWalker297 arg) (\_ -> fanWalker297 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker149 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker199 body) Nothing (\inner -> fanWalker199 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 299; branches to fanWalker298, fanWalker150, fanWalker200.
+fanWalker299 :: Core.Term -> Maybe Core.Term
+fanWalker299 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker298 fun) (fanWalker298 arg) (\_ -> fanWalker298 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker150 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker200 body) Nothing (\inner -> fanWalker200 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 3; branches to fanWalker2, fanWalker2, fanWalker2.
+fanWalker3 :: Core.Term -> Maybe Core.Term
+fanWalker3 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker2 fun) (fanWalker2 arg) (\_ -> fanWalker2 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker2 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker2 body) Nothing (\inner -> fanWalker2 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 30; branches to fanWalker29, fanWalker15, fanWalker20.
+fanWalker30 :: Core.Term -> Maybe Core.Term
+fanWalker30 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker29 fun) (fanWalker29 arg) (\_ -> fanWalker29 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker15 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker20 body) Nothing (\inner -> fanWalker20 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 300; branches to fanWalker299, fanWalker150, fanWalker200.
+fanWalker300 :: Core.Term -> Maybe Core.Term
+fanWalker300 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker299 fun) (fanWalker299 arg) (\_ -> fanWalker299 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker150 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker200 body) Nothing (\inner -> fanWalker200 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 301; branches to fanWalker300, fanWalker151, fanWalker201.
+fanWalker301 :: Core.Term -> Maybe Core.Term
+fanWalker301 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker300 fun) (fanWalker300 arg) (\_ -> fanWalker300 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker151 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker201 body) Nothing (\inner -> fanWalker201 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 302; branches to fanWalker301, fanWalker151, fanWalker202.
+fanWalker302 :: Core.Term -> Maybe Core.Term
+fanWalker302 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker301 fun) (fanWalker301 arg) (\_ -> fanWalker301 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker151 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker202 body) Nothing (\inner -> fanWalker202 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 303; branches to fanWalker302, fanWalker152, fanWalker202.
+fanWalker303 :: Core.Term -> Maybe Core.Term
+fanWalker303 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker302 fun) (fanWalker302 arg) (\_ -> fanWalker302 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker152 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker202 body) Nothing (\inner -> fanWalker202 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 304; branches to fanWalker303, fanWalker152, fanWalker203.
+fanWalker304 :: Core.Term -> Maybe Core.Term
+fanWalker304 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker303 fun) (fanWalker303 arg) (\_ -> fanWalker303 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker152 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker203 body) Nothing (\inner -> fanWalker203 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 305; branches to fanWalker304, fanWalker153, fanWalker204.
+fanWalker305 :: Core.Term -> Maybe Core.Term
+fanWalker305 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker304 fun) (fanWalker304 arg) (\_ -> fanWalker304 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker153 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker204 body) Nothing (\inner -> fanWalker204 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 306; branches to fanWalker305, fanWalker153, fanWalker204.
+fanWalker306 :: Core.Term -> Maybe Core.Term
+fanWalker306 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker305 fun) (fanWalker305 arg) (\_ -> fanWalker305 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker153 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker204 body) Nothing (\inner -> fanWalker204 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 307; branches to fanWalker306, fanWalker154, fanWalker205.
+fanWalker307 :: Core.Term -> Maybe Core.Term
+fanWalker307 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker306 fun) (fanWalker306 arg) (\_ -> fanWalker306 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker154 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker205 body) Nothing (\inner -> fanWalker205 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 308; branches to fanWalker307, fanWalker154, fanWalker206.
+fanWalker308 :: Core.Term -> Maybe Core.Term
+fanWalker308 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker307 fun) (fanWalker307 arg) (\_ -> fanWalker307 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker154 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker206 body) Nothing (\inner -> fanWalker206 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 309; branches to fanWalker308, fanWalker155, fanWalker206.
+fanWalker309 :: Core.Term -> Maybe Core.Term
+fanWalker309 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker308 fun) (fanWalker308 arg) (\_ -> fanWalker308 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker155 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker206 body) Nothing (\inner -> fanWalker206 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 31; branches to fanWalker30, fanWalker16, fanWalker21.
+fanWalker31 :: Core.Term -> Maybe Core.Term
+fanWalker31 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker30 fun) (fanWalker30 arg) (\_ -> fanWalker30 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker16 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker21 body) Nothing (\inner -> fanWalker21 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 310; branches to fanWalker309, fanWalker155, fanWalker207.
+fanWalker310 :: Core.Term -> Maybe Core.Term
+fanWalker310 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker309 fun) (fanWalker309 arg) (\_ -> fanWalker309 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker155 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker207 body) Nothing (\inner -> fanWalker207 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 311; branches to fanWalker310, fanWalker156, fanWalker208.
+fanWalker311 :: Core.Term -> Maybe Core.Term
+fanWalker311 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker310 fun) (fanWalker310 arg) (\_ -> fanWalker310 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker156 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker208 body) Nothing (\inner -> fanWalker208 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 312; branches to fanWalker311, fanWalker156, fanWalker208.
+fanWalker312 :: Core.Term -> Maybe Core.Term
+fanWalker312 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker311 fun) (fanWalker311 arg) (\_ -> fanWalker311 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker156 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker208 body) Nothing (\inner -> fanWalker208 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 313; branches to fanWalker312, fanWalker157, fanWalker209.
+fanWalker313 :: Core.Term -> Maybe Core.Term
+fanWalker313 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker312 fun) (fanWalker312 arg) (\_ -> fanWalker312 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker157 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker209 body) Nothing (\inner -> fanWalker209 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 314; branches to fanWalker313, fanWalker157, fanWalker210.
+fanWalker314 :: Core.Term -> Maybe Core.Term
+fanWalker314 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker313 fun) (fanWalker313 arg) (\_ -> fanWalker313 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker157 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker210 body) Nothing (\inner -> fanWalker210 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 315; branches to fanWalker314, fanWalker158, fanWalker210.
+fanWalker315 :: Core.Term -> Maybe Core.Term
+fanWalker315 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker314 fun) (fanWalker314 arg) (\_ -> fanWalker314 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker158 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker210 body) Nothing (\inner -> fanWalker210 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 316; branches to fanWalker315, fanWalker158, fanWalker211.
+fanWalker316 :: Core.Term -> Maybe Core.Term
+fanWalker316 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker315 fun) (fanWalker315 arg) (\_ -> fanWalker315 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker158 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker211 body) Nothing (\inner -> fanWalker211 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 317; branches to fanWalker316, fanWalker159, fanWalker212.
+fanWalker317 :: Core.Term -> Maybe Core.Term
+fanWalker317 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker316 fun) (fanWalker316 arg) (\_ -> fanWalker316 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker159 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker212 body) Nothing (\inner -> fanWalker212 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 318; branches to fanWalker317, fanWalker159, fanWalker212.
+fanWalker318 :: Core.Term -> Maybe Core.Term
+fanWalker318 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker317 fun) (fanWalker317 arg) (\_ -> fanWalker317 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker159 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker212 body) Nothing (\inner -> fanWalker212 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 319; branches to fanWalker318, fanWalker160, fanWalker213.
+fanWalker319 :: Core.Term -> Maybe Core.Term
+fanWalker319 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker318 fun) (fanWalker318 arg) (\_ -> fanWalker318 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker160 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker213 body) Nothing (\inner -> fanWalker213 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 32; branches to fanWalker31, fanWalker16, fanWalker22.
+fanWalker32 :: Core.Term -> Maybe Core.Term
+fanWalker32 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker31 fun) (fanWalker31 arg) (\_ -> fanWalker31 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker16 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker22 body) Nothing (\inner -> fanWalker22 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 320; branches to fanWalker319, fanWalker160, fanWalker214.
+fanWalker320 :: Core.Term -> Maybe Core.Term
+fanWalker320 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker319 fun) (fanWalker319 arg) (\_ -> fanWalker319 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker160 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker214 body) Nothing (\inner -> fanWalker214 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 321; branches to fanWalker320, fanWalker161, fanWalker214.
+fanWalker321 :: Core.Term -> Maybe Core.Term
+fanWalker321 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker320 fun) (fanWalker320 arg) (\_ -> fanWalker320 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker161 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker214 body) Nothing (\inner -> fanWalker214 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 322; branches to fanWalker321, fanWalker161, fanWalker215.
+fanWalker322 :: Core.Term -> Maybe Core.Term
+fanWalker322 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker321 fun) (fanWalker321 arg) (\_ -> fanWalker321 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker161 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker215 body) Nothing (\inner -> fanWalker215 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 323; branches to fanWalker322, fanWalker162, fanWalker216.
+fanWalker323 :: Core.Term -> Maybe Core.Term
+fanWalker323 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker322 fun) (fanWalker322 arg) (\_ -> fanWalker322 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker162 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker216 body) Nothing (\inner -> fanWalker216 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 324; branches to fanWalker323, fanWalker162, fanWalker216.
+fanWalker324 :: Core.Term -> Maybe Core.Term
+fanWalker324 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker323 fun) (fanWalker323 arg) (\_ -> fanWalker323 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker162 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker216 body) Nothing (\inner -> fanWalker216 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 325; branches to fanWalker324, fanWalker163, fanWalker217.
+fanWalker325 :: Core.Term -> Maybe Core.Term
+fanWalker325 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker324 fun) (fanWalker324 arg) (\_ -> fanWalker324 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker163 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker217 body) Nothing (\inner -> fanWalker217 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 326; branches to fanWalker325, fanWalker163, fanWalker218.
+fanWalker326 :: Core.Term -> Maybe Core.Term
+fanWalker326 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker325 fun) (fanWalker325 arg) (\_ -> fanWalker325 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker163 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker218 body) Nothing (\inner -> fanWalker218 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 327; branches to fanWalker326, fanWalker164, fanWalker218.
+fanWalker327 :: Core.Term -> Maybe Core.Term
+fanWalker327 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker326 fun) (fanWalker326 arg) (\_ -> fanWalker326 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker164 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker218 body) Nothing (\inner -> fanWalker218 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 328; branches to fanWalker327, fanWalker164, fanWalker219.
+fanWalker328 :: Core.Term -> Maybe Core.Term
+fanWalker328 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker327 fun) (fanWalker327 arg) (\_ -> fanWalker327 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker164 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker219 body) Nothing (\inner -> fanWalker219 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 329; branches to fanWalker328, fanWalker165, fanWalker220.
+fanWalker329 :: Core.Term -> Maybe Core.Term
+fanWalker329 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker328 fun) (fanWalker328 arg) (\_ -> fanWalker328 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker165 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker220 body) Nothing (\inner -> fanWalker220 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 33; branches to fanWalker32, fanWalker17, fanWalker22.
+fanWalker33 :: Core.Term -> Maybe Core.Term
+fanWalker33 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker32 fun) (fanWalker32 arg) (\_ -> fanWalker32 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker17 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker22 body) Nothing (\inner -> fanWalker22 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 330; branches to fanWalker329, fanWalker165, fanWalker220.
+fanWalker330 :: Core.Term -> Maybe Core.Term
+fanWalker330 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker329 fun) (fanWalker329 arg) (\_ -> fanWalker329 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker165 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker220 body) Nothing (\inner -> fanWalker220 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 331; branches to fanWalker330, fanWalker166, fanWalker221.
+fanWalker331 :: Core.Term -> Maybe Core.Term
+fanWalker331 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker330 fun) (fanWalker330 arg) (\_ -> fanWalker330 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker166 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker221 body) Nothing (\inner -> fanWalker221 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 332; branches to fanWalker331, fanWalker166, fanWalker222.
+fanWalker332 :: Core.Term -> Maybe Core.Term
+fanWalker332 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker331 fun) (fanWalker331 arg) (\_ -> fanWalker331 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker166 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker222 body) Nothing (\inner -> fanWalker222 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 333; branches to fanWalker332, fanWalker167, fanWalker222.
+fanWalker333 :: Core.Term -> Maybe Core.Term
+fanWalker333 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker332 fun) (fanWalker332 arg) (\_ -> fanWalker332 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker167 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker222 body) Nothing (\inner -> fanWalker222 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 334; branches to fanWalker333, fanWalker167, fanWalker223.
+fanWalker334 :: Core.Term -> Maybe Core.Term
+fanWalker334 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker333 fun) (fanWalker333 arg) (\_ -> fanWalker333 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker167 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker223 body) Nothing (\inner -> fanWalker223 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 335; branches to fanWalker334, fanWalker168, fanWalker224.
+fanWalker335 :: Core.Term -> Maybe Core.Term
+fanWalker335 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker334 fun) (fanWalker334 arg) (\_ -> fanWalker334 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker168 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker224 body) Nothing (\inner -> fanWalker224 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 336; branches to fanWalker335, fanWalker168, fanWalker224.
+fanWalker336 :: Core.Term -> Maybe Core.Term
+fanWalker336 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker335 fun) (fanWalker335 arg) (\_ -> fanWalker335 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker168 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker224 body) Nothing (\inner -> fanWalker224 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 337; branches to fanWalker336, fanWalker169, fanWalker225.
+fanWalker337 :: Core.Term -> Maybe Core.Term
+fanWalker337 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker336 fun) (fanWalker336 arg) (\_ -> fanWalker336 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker169 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker225 body) Nothing (\inner -> fanWalker225 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 338; branches to fanWalker337, fanWalker169, fanWalker226.
+fanWalker338 :: Core.Term -> Maybe Core.Term
+fanWalker338 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker337 fun) (fanWalker337 arg) (\_ -> fanWalker337 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker169 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker226 body) Nothing (\inner -> fanWalker226 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 339; branches to fanWalker338, fanWalker170, fanWalker226.
+fanWalker339 :: Core.Term -> Maybe Core.Term
+fanWalker339 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker338 fun) (fanWalker338 arg) (\_ -> fanWalker338 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker170 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker226 body) Nothing (\inner -> fanWalker226 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 34; branches to fanWalker33, fanWalker17, fanWalker23.
+fanWalker34 :: Core.Term -> Maybe Core.Term
+fanWalker34 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker33 fun) (fanWalker33 arg) (\_ -> fanWalker33 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker17 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker23 body) Nothing (\inner -> fanWalker23 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 340; branches to fanWalker339, fanWalker170, fanWalker227.
+fanWalker340 :: Core.Term -> Maybe Core.Term
+fanWalker340 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker339 fun) (fanWalker339 arg) (\_ -> fanWalker339 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker170 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker227 body) Nothing (\inner -> fanWalker227 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 341; branches to fanWalker340, fanWalker171, fanWalker228.
+fanWalker341 :: Core.Term -> Maybe Core.Term
+fanWalker341 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker340 fun) (fanWalker340 arg) (\_ -> fanWalker340 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker171 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker228 body) Nothing (\inner -> fanWalker228 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 342; branches to fanWalker341, fanWalker171, fanWalker228.
+fanWalker342 :: Core.Term -> Maybe Core.Term
+fanWalker342 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker341 fun) (fanWalker341 arg) (\_ -> fanWalker341 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker171 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker228 body) Nothing (\inner -> fanWalker228 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 343; branches to fanWalker342, fanWalker172, fanWalker229.
+fanWalker343 :: Core.Term -> Maybe Core.Term
+fanWalker343 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker342 fun) (fanWalker342 arg) (\_ -> fanWalker342 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker172 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker229 body) Nothing (\inner -> fanWalker229 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 344; branches to fanWalker343, fanWalker172, fanWalker230.
+fanWalker344 :: Core.Term -> Maybe Core.Term
+fanWalker344 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker343 fun) (fanWalker343 arg) (\_ -> fanWalker343 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker172 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker230 body) Nothing (\inner -> fanWalker230 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 345; branches to fanWalker344, fanWalker173, fanWalker230.
+fanWalker345 :: Core.Term -> Maybe Core.Term
+fanWalker345 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker344 fun) (fanWalker344 arg) (\_ -> fanWalker344 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker173 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker230 body) Nothing (\inner -> fanWalker230 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 346; branches to fanWalker345, fanWalker173, fanWalker231.
+fanWalker346 :: Core.Term -> Maybe Core.Term
+fanWalker346 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker345 fun) (fanWalker345 arg) (\_ -> fanWalker345 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker173 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker231 body) Nothing (\inner -> fanWalker231 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 347; branches to fanWalker346, fanWalker174, fanWalker232.
+fanWalker347 :: Core.Term -> Maybe Core.Term
+fanWalker347 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker346 fun) (fanWalker346 arg) (\_ -> fanWalker346 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker174 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker232 body) Nothing (\inner -> fanWalker232 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 348; branches to fanWalker347, fanWalker174, fanWalker232.
+fanWalker348 :: Core.Term -> Maybe Core.Term
+fanWalker348 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker347 fun) (fanWalker347 arg) (\_ -> fanWalker347 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker174 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker232 body) Nothing (\inner -> fanWalker232 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 349; branches to fanWalker348, fanWalker175, fanWalker233.
+fanWalker349 :: Core.Term -> Maybe Core.Term
+fanWalker349 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker348 fun) (fanWalker348 arg) (\_ -> fanWalker348 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker175 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker233 body) Nothing (\inner -> fanWalker233 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 35; branches to fanWalker34, fanWalker18, fanWalker24.
+fanWalker35 :: Core.Term -> Maybe Core.Term
+fanWalker35 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker34 fun) (fanWalker34 arg) (\_ -> fanWalker34 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker18 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker24 body) Nothing (\inner -> fanWalker24 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 350; branches to fanWalker349, fanWalker175, fanWalker234.
+fanWalker350 :: Core.Term -> Maybe Core.Term
+fanWalker350 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker349 fun) (fanWalker349 arg) (\_ -> fanWalker349 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker175 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker234 body) Nothing (\inner -> fanWalker234 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 351; branches to fanWalker350, fanWalker176, fanWalker234.
+fanWalker351 :: Core.Term -> Maybe Core.Term
+fanWalker351 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker350 fun) (fanWalker350 arg) (\_ -> fanWalker350 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker176 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker234 body) Nothing (\inner -> fanWalker234 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 352; branches to fanWalker351, fanWalker176, fanWalker235.
+fanWalker352 :: Core.Term -> Maybe Core.Term
+fanWalker352 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker351 fun) (fanWalker351 arg) (\_ -> fanWalker351 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker176 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker235 body) Nothing (\inner -> fanWalker235 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 353; branches to fanWalker352, fanWalker177, fanWalker236.
+fanWalker353 :: Core.Term -> Maybe Core.Term
+fanWalker353 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker352 fun) (fanWalker352 arg) (\_ -> fanWalker352 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker177 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker236 body) Nothing (\inner -> fanWalker236 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 354; branches to fanWalker353, fanWalker177, fanWalker236.
+fanWalker354 :: Core.Term -> Maybe Core.Term
+fanWalker354 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker353 fun) (fanWalker353 arg) (\_ -> fanWalker353 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker177 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker236 body) Nothing (\inner -> fanWalker236 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 355; branches to fanWalker354, fanWalker178, fanWalker237.
+fanWalker355 :: Core.Term -> Maybe Core.Term
+fanWalker355 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker354 fun) (fanWalker354 arg) (\_ -> fanWalker354 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker178 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker237 body) Nothing (\inner -> fanWalker237 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 356; branches to fanWalker355, fanWalker178, fanWalker238.
+fanWalker356 :: Core.Term -> Maybe Core.Term
+fanWalker356 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker355 fun) (fanWalker355 arg) (\_ -> fanWalker355 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker178 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker238 body) Nothing (\inner -> fanWalker238 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 357; branches to fanWalker356, fanWalker179, fanWalker238.
+fanWalker357 :: Core.Term -> Maybe Core.Term
+fanWalker357 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker356 fun) (fanWalker356 arg) (\_ -> fanWalker356 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker179 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker238 body) Nothing (\inner -> fanWalker238 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 358; branches to fanWalker357, fanWalker179, fanWalker239.
+fanWalker358 :: Core.Term -> Maybe Core.Term
+fanWalker358 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker357 fun) (fanWalker357 arg) (\_ -> fanWalker357 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker179 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker239 body) Nothing (\inner -> fanWalker239 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 359; branches to fanWalker358, fanWalker180, fanWalker240.
+fanWalker359 :: Core.Term -> Maybe Core.Term
+fanWalker359 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker358 fun) (fanWalker358 arg) (\_ -> fanWalker358 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker180 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker240 body) Nothing (\inner -> fanWalker240 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 36; branches to fanWalker35, fanWalker18, fanWalker24.
+fanWalker36 :: Core.Term -> Maybe Core.Term
+fanWalker36 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker35 fun) (fanWalker35 arg) (\_ -> fanWalker35 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker18 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker24 body) Nothing (\inner -> fanWalker24 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 360; branches to fanWalker359, fanWalker180, fanWalker240.
+fanWalker360 :: Core.Term -> Maybe Core.Term
+fanWalker360 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker359 fun) (fanWalker359 arg) (\_ -> fanWalker359 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker180 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker240 body) Nothing (\inner -> fanWalker240 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 361; branches to fanWalker360, fanWalker181, fanWalker241.
+fanWalker361 :: Core.Term -> Maybe Core.Term
+fanWalker361 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker360 fun) (fanWalker360 arg) (\_ -> fanWalker360 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker181 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker241 body) Nothing (\inner -> fanWalker241 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 362; branches to fanWalker361, fanWalker181, fanWalker242.
+fanWalker362 :: Core.Term -> Maybe Core.Term
+fanWalker362 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker361 fun) (fanWalker361 arg) (\_ -> fanWalker361 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker181 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker242 body) Nothing (\inner -> fanWalker242 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 363; branches to fanWalker362, fanWalker182, fanWalker242.
+fanWalker363 :: Core.Term -> Maybe Core.Term
+fanWalker363 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker362 fun) (fanWalker362 arg) (\_ -> fanWalker362 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker182 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker242 body) Nothing (\inner -> fanWalker242 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 364; branches to fanWalker363, fanWalker182, fanWalker243.
+fanWalker364 :: Core.Term -> Maybe Core.Term
+fanWalker364 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker363 fun) (fanWalker363 arg) (\_ -> fanWalker363 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker182 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker243 body) Nothing (\inner -> fanWalker243 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 365; branches to fanWalker364, fanWalker183, fanWalker244.
+fanWalker365 :: Core.Term -> Maybe Core.Term
+fanWalker365 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker364 fun) (fanWalker364 arg) (\_ -> fanWalker364 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker183 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker244 body) Nothing (\inner -> fanWalker244 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 366; branches to fanWalker365, fanWalker183, fanWalker244.
+fanWalker366 :: Core.Term -> Maybe Core.Term
+fanWalker366 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker365 fun) (fanWalker365 arg) (\_ -> fanWalker365 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker183 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker244 body) Nothing (\inner -> fanWalker244 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 367; branches to fanWalker366, fanWalker184, fanWalker245.
+fanWalker367 :: Core.Term -> Maybe Core.Term
+fanWalker367 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker366 fun) (fanWalker366 arg) (\_ -> fanWalker366 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker184 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker245 body) Nothing (\inner -> fanWalker245 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 368; branches to fanWalker367, fanWalker184, fanWalker246.
+fanWalker368 :: Core.Term -> Maybe Core.Term
+fanWalker368 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker367 fun) (fanWalker367 arg) (\_ -> fanWalker367 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker184 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker246 body) Nothing (\inner -> fanWalker246 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 369; branches to fanWalker368, fanWalker185, fanWalker246.
+fanWalker369 :: Core.Term -> Maybe Core.Term
+fanWalker369 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker368 fun) (fanWalker368 arg) (\_ -> fanWalker368 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker185 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker246 body) Nothing (\inner -> fanWalker246 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 37; branches to fanWalker36, fanWalker19, fanWalker25.
+fanWalker37 :: Core.Term -> Maybe Core.Term
+fanWalker37 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker36 fun) (fanWalker36 arg) (\_ -> fanWalker36 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker19 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker25 body) Nothing (\inner -> fanWalker25 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 370; branches to fanWalker369, fanWalker185, fanWalker247.
+fanWalker370 :: Core.Term -> Maybe Core.Term
+fanWalker370 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker369 fun) (fanWalker369 arg) (\_ -> fanWalker369 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker185 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker247 body) Nothing (\inner -> fanWalker247 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 371; branches to fanWalker370, fanWalker186, fanWalker248.
+fanWalker371 :: Core.Term -> Maybe Core.Term
+fanWalker371 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker370 fun) (fanWalker370 arg) (\_ -> fanWalker370 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker186 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker248 body) Nothing (\inner -> fanWalker248 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 372; branches to fanWalker371, fanWalker186, fanWalker248.
+fanWalker372 :: Core.Term -> Maybe Core.Term
+fanWalker372 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker371 fun) (fanWalker371 arg) (\_ -> fanWalker371 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker186 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker248 body) Nothing (\inner -> fanWalker248 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 373; branches to fanWalker372, fanWalker187, fanWalker249.
+fanWalker373 :: Core.Term -> Maybe Core.Term
+fanWalker373 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker372 fun) (fanWalker372 arg) (\_ -> fanWalker372 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker187 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker249 body) Nothing (\inner -> fanWalker249 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 374; branches to fanWalker373, fanWalker187, fanWalker250.
+fanWalker374 :: Core.Term -> Maybe Core.Term
+fanWalker374 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker373 fun) (fanWalker373 arg) (\_ -> fanWalker373 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker187 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker250 body) Nothing (\inner -> fanWalker250 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 375; branches to fanWalker374, fanWalker188, fanWalker250.
+fanWalker375 :: Core.Term -> Maybe Core.Term
+fanWalker375 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker374 fun) (fanWalker374 arg) (\_ -> fanWalker374 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker188 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker250 body) Nothing (\inner -> fanWalker250 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 376; branches to fanWalker375, fanWalker188, fanWalker251.
+fanWalker376 :: Core.Term -> Maybe Core.Term
+fanWalker376 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker375 fun) (fanWalker375 arg) (\_ -> fanWalker375 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker188 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker251 body) Nothing (\inner -> fanWalker251 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 377; branches to fanWalker376, fanWalker189, fanWalker252.
+fanWalker377 :: Core.Term -> Maybe Core.Term
+fanWalker377 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker376 fun) (fanWalker376 arg) (\_ -> fanWalker376 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker189 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker252 body) Nothing (\inner -> fanWalker252 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 378; branches to fanWalker377, fanWalker189, fanWalker252.
+fanWalker378 :: Core.Term -> Maybe Core.Term
+fanWalker378 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker377 fun) (fanWalker377 arg) (\_ -> fanWalker377 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker189 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker252 body) Nothing (\inner -> fanWalker252 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 379; branches to fanWalker378, fanWalker190, fanWalker253.
+fanWalker379 :: Core.Term -> Maybe Core.Term
+fanWalker379 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker378 fun) (fanWalker378 arg) (\_ -> fanWalker378 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker190 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker253 body) Nothing (\inner -> fanWalker253 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 38; branches to fanWalker37, fanWalker19, fanWalker26.
+fanWalker38 :: Core.Term -> Maybe Core.Term
+fanWalker38 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker37 fun) (fanWalker37 arg) (\_ -> fanWalker37 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker19 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker26 body) Nothing (\inner -> fanWalker26 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 380; branches to fanWalker379, fanWalker190, fanWalker254.
+fanWalker380 :: Core.Term -> Maybe Core.Term
+fanWalker380 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker379 fun) (fanWalker379 arg) (\_ -> fanWalker379 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker190 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker254 body) Nothing (\inner -> fanWalker254 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 381; branches to fanWalker380, fanWalker191, fanWalker254.
+fanWalker381 :: Core.Term -> Maybe Core.Term
+fanWalker381 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker380 fun) (fanWalker380 arg) (\_ -> fanWalker380 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker191 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker254 body) Nothing (\inner -> fanWalker254 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 382; branches to fanWalker381, fanWalker191, fanWalker255.
+fanWalker382 :: Core.Term -> Maybe Core.Term
+fanWalker382 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker381 fun) (fanWalker381 arg) (\_ -> fanWalker381 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker191 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker255 body) Nothing (\inner -> fanWalker255 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 383; branches to fanWalker382, fanWalker192, fanWalker256.
+fanWalker383 :: Core.Term -> Maybe Core.Term
+fanWalker383 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker382 fun) (fanWalker382 arg) (\_ -> fanWalker382 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker192 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker256 body) Nothing (\inner -> fanWalker256 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 384; branches to fanWalker383, fanWalker192, fanWalker256.
+fanWalker384 :: Core.Term -> Maybe Core.Term
+fanWalker384 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker383 fun) (fanWalker383 arg) (\_ -> fanWalker383 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker192 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker256 body) Nothing (\inner -> fanWalker256 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 385; branches to fanWalker384, fanWalker193, fanWalker257.
+fanWalker385 :: Core.Term -> Maybe Core.Term
+fanWalker385 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker384 fun) (fanWalker384 arg) (\_ -> fanWalker384 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker193 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker257 body) Nothing (\inner -> fanWalker257 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 386; branches to fanWalker385, fanWalker193, fanWalker258.
+fanWalker386 :: Core.Term -> Maybe Core.Term
+fanWalker386 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker385 fun) (fanWalker385 arg) (\_ -> fanWalker385 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker193 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker258 body) Nothing (\inner -> fanWalker258 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 387; branches to fanWalker386, fanWalker194, fanWalker258.
+fanWalker387 :: Core.Term -> Maybe Core.Term
+fanWalker387 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker386 fun) (fanWalker386 arg) (\_ -> fanWalker386 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker194 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker258 body) Nothing (\inner -> fanWalker258 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 388; branches to fanWalker387, fanWalker194, fanWalker259.
+fanWalker388 :: Core.Term -> Maybe Core.Term
+fanWalker388 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker387 fun) (fanWalker387 arg) (\_ -> fanWalker387 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker194 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker259 body) Nothing (\inner -> fanWalker259 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 389; branches to fanWalker388, fanWalker195, fanWalker260.
+fanWalker389 :: Core.Term -> Maybe Core.Term
+fanWalker389 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker388 fun) (fanWalker388 arg) (\_ -> fanWalker388 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker195 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker260 body) Nothing (\inner -> fanWalker260 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 39; branches to fanWalker38, fanWalker20, fanWalker26.
+fanWalker39 :: Core.Term -> Maybe Core.Term
+fanWalker39 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker38 fun) (fanWalker38 arg) (\_ -> fanWalker38 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker20 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker26 body) Nothing (\inner -> fanWalker26 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 390; branches to fanWalker389, fanWalker195, fanWalker260.
+fanWalker390 :: Core.Term -> Maybe Core.Term
+fanWalker390 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker389 fun) (fanWalker389 arg) (\_ -> fanWalker389 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker195 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker260 body) Nothing (\inner -> fanWalker260 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 391; branches to fanWalker390, fanWalker196, fanWalker261.
+fanWalker391 :: Core.Term -> Maybe Core.Term
+fanWalker391 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker390 fun) (fanWalker390 arg) (\_ -> fanWalker390 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker196 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker261 body) Nothing (\inner -> fanWalker261 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 392; branches to fanWalker391, fanWalker196, fanWalker262.
+fanWalker392 :: Core.Term -> Maybe Core.Term
+fanWalker392 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker391 fun) (fanWalker391 arg) (\_ -> fanWalker391 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker196 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker262 body) Nothing (\inner -> fanWalker262 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 393; branches to fanWalker392, fanWalker197, fanWalker262.
+fanWalker393 :: Core.Term -> Maybe Core.Term
+fanWalker393 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker392 fun) (fanWalker392 arg) (\_ -> fanWalker392 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker197 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker262 body) Nothing (\inner -> fanWalker262 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 394; branches to fanWalker393, fanWalker197, fanWalker263.
+fanWalker394 :: Core.Term -> Maybe Core.Term
+fanWalker394 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker393 fun) (fanWalker393 arg) (\_ -> fanWalker393 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker197 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker263 body) Nothing (\inner -> fanWalker263 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 395; branches to fanWalker394, fanWalker198, fanWalker264.
+fanWalker395 :: Core.Term -> Maybe Core.Term
+fanWalker395 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker394 fun) (fanWalker394 arg) (\_ -> fanWalker394 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker198 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker264 body) Nothing (\inner -> fanWalker264 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 396; branches to fanWalker395, fanWalker198, fanWalker264.
+fanWalker396 :: Core.Term -> Maybe Core.Term
+fanWalker396 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker395 fun) (fanWalker395 arg) (\_ -> fanWalker395 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker198 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker264 body) Nothing (\inner -> fanWalker264 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 397; branches to fanWalker396, fanWalker199, fanWalker265.
+fanWalker397 :: Core.Term -> Maybe Core.Term
+fanWalker397 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker396 fun) (fanWalker396 arg) (\_ -> fanWalker396 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker199 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker265 body) Nothing (\inner -> fanWalker265 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 398; branches to fanWalker397, fanWalker199, fanWalker266.
+fanWalker398 :: Core.Term -> Maybe Core.Term
+fanWalker398 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker397 fun) (fanWalker397 arg) (\_ -> fanWalker397 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker199 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker266 body) Nothing (\inner -> fanWalker266 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 399; branches to fanWalker398, fanWalker200, fanWalker266.
+fanWalker399 :: Core.Term -> Maybe Core.Term
+fanWalker399 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker398 fun) (fanWalker398 arg) (\_ -> fanWalker398 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker200 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker266 body) Nothing (\inner -> fanWalker266 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 4; branches to fanWalker3, fanWalker2, fanWalker3.
+fanWalker4 :: Core.Term -> Maybe Core.Term
+fanWalker4 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker3 fun) (fanWalker3 arg) (\_ -> fanWalker3 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker2 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker3 body) Nothing (\inner -> fanWalker3 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 40; branches to fanWalker39, fanWalker20, fanWalker27.
+fanWalker40 :: Core.Term -> Maybe Core.Term
+fanWalker40 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker39 fun) (fanWalker39 arg) (\_ -> fanWalker39 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker20 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker27 body) Nothing (\inner -> fanWalker27 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 41; branches to fanWalker40, fanWalker21, fanWalker28.
+fanWalker41 :: Core.Term -> Maybe Core.Term
+fanWalker41 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker40 fun) (fanWalker40 arg) (\_ -> fanWalker40 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker21 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker28 body) Nothing (\inner -> fanWalker28 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 42; branches to fanWalker41, fanWalker21, fanWalker28.
+fanWalker42 :: Core.Term -> Maybe Core.Term
+fanWalker42 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker41 fun) (fanWalker41 arg) (\_ -> fanWalker41 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker21 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker28 body) Nothing (\inner -> fanWalker28 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 43; branches to fanWalker42, fanWalker22, fanWalker29.
+fanWalker43 :: Core.Term -> Maybe Core.Term
+fanWalker43 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker42 fun) (fanWalker42 arg) (\_ -> fanWalker42 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker22 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker29 body) Nothing (\inner -> fanWalker29 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 44; branches to fanWalker43, fanWalker22, fanWalker30.
+fanWalker44 :: Core.Term -> Maybe Core.Term
+fanWalker44 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker43 fun) (fanWalker43 arg) (\_ -> fanWalker43 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker22 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker30 body) Nothing (\inner -> fanWalker30 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 45; branches to fanWalker44, fanWalker23, fanWalker30.
+fanWalker45 :: Core.Term -> Maybe Core.Term
+fanWalker45 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker44 fun) (fanWalker44 arg) (\_ -> fanWalker44 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker23 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker30 body) Nothing (\inner -> fanWalker30 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 46; branches to fanWalker45, fanWalker23, fanWalker31.
+fanWalker46 :: Core.Term -> Maybe Core.Term
+fanWalker46 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker45 fun) (fanWalker45 arg) (\_ -> fanWalker45 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker23 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker31 body) Nothing (\inner -> fanWalker31 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 47; branches to fanWalker46, fanWalker24, fanWalker32.
+fanWalker47 :: Core.Term -> Maybe Core.Term
+fanWalker47 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker46 fun) (fanWalker46 arg) (\_ -> fanWalker46 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker24 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker32 body) Nothing (\inner -> fanWalker32 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 48; branches to fanWalker47, fanWalker24, fanWalker32.
+fanWalker48 :: Core.Term -> Maybe Core.Term
+fanWalker48 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker47 fun) (fanWalker47 arg) (\_ -> fanWalker47 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker24 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker32 body) Nothing (\inner -> fanWalker32 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 49; branches to fanWalker48, fanWalker25, fanWalker33.
+fanWalker49 :: Core.Term -> Maybe Core.Term
+fanWalker49 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker48 fun) (fanWalker48 arg) (\_ -> fanWalker48 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker25 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker33 body) Nothing (\inner -> fanWalker33 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 5; branches to fanWalker4, fanWalker3, fanWalker4.
+fanWalker5 :: Core.Term -> Maybe Core.Term
+fanWalker5 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker4 fun) (fanWalker4 arg) (\_ -> fanWalker4 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker3 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker4 body) Nothing (\inner -> fanWalker4 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 50; branches to fanWalker49, fanWalker25, fanWalker34.
+fanWalker50 :: Core.Term -> Maybe Core.Term
+fanWalker50 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker49 fun) (fanWalker49 arg) (\_ -> fanWalker49 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker25 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker34 body) Nothing (\inner -> fanWalker34 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 51; branches to fanWalker50, fanWalker26, fanWalker34.
+fanWalker51 :: Core.Term -> Maybe Core.Term
+fanWalker51 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker50 fun) (fanWalker50 arg) (\_ -> fanWalker50 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker26 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker34 body) Nothing (\inner -> fanWalker34 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 52; branches to fanWalker51, fanWalker26, fanWalker35.
+fanWalker52 :: Core.Term -> Maybe Core.Term
+fanWalker52 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker51 fun) (fanWalker51 arg) (\_ -> fanWalker51 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker26 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker35 body) Nothing (\inner -> fanWalker35 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 53; branches to fanWalker52, fanWalker27, fanWalker36.
+fanWalker53 :: Core.Term -> Maybe Core.Term
+fanWalker53 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker52 fun) (fanWalker52 arg) (\_ -> fanWalker52 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker27 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker36 body) Nothing (\inner -> fanWalker36 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 54; branches to fanWalker53, fanWalker27, fanWalker36.
+fanWalker54 :: Core.Term -> Maybe Core.Term
+fanWalker54 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker53 fun) (fanWalker53 arg) (\_ -> fanWalker53 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker27 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker36 body) Nothing (\inner -> fanWalker36 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 55; branches to fanWalker54, fanWalker28, fanWalker37.
+fanWalker55 :: Core.Term -> Maybe Core.Term
+fanWalker55 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker54 fun) (fanWalker54 arg) (\_ -> fanWalker54 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker28 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker37 body) Nothing (\inner -> fanWalker37 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 56; branches to fanWalker55, fanWalker28, fanWalker38.
+fanWalker56 :: Core.Term -> Maybe Core.Term
+fanWalker56 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker55 fun) (fanWalker55 arg) (\_ -> fanWalker55 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker28 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker38 body) Nothing (\inner -> fanWalker38 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 57; branches to fanWalker56, fanWalker29, fanWalker38.
+fanWalker57 :: Core.Term -> Maybe Core.Term
+fanWalker57 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker56 fun) (fanWalker56 arg) (\_ -> fanWalker56 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker29 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker38 body) Nothing (\inner -> fanWalker38 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 58; branches to fanWalker57, fanWalker29, fanWalker39.
+fanWalker58 :: Core.Term -> Maybe Core.Term
+fanWalker58 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker57 fun) (fanWalker57 arg) (\_ -> fanWalker57 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker29 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker39 body) Nothing (\inner -> fanWalker39 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 59; branches to fanWalker58, fanWalker30, fanWalker40.
+fanWalker59 :: Core.Term -> Maybe Core.Term
+fanWalker59 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker58 fun) (fanWalker58 arg) (\_ -> fanWalker58 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker30 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker40 body) Nothing (\inner -> fanWalker40 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 6; branches to fanWalker5, fanWalker3, fanWalker4.
+fanWalker6 :: Core.Term -> Maybe Core.Term
+fanWalker6 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker5 fun) (fanWalker5 arg) (\_ -> fanWalker5 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker3 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker4 body) Nothing (\inner -> fanWalker4 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 60; branches to fanWalker59, fanWalker30, fanWalker40.
+fanWalker60 :: Core.Term -> Maybe Core.Term
+fanWalker60 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker59 fun) (fanWalker59 arg) (\_ -> fanWalker59 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker30 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker40 body) Nothing (\inner -> fanWalker40 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 61; branches to fanWalker60, fanWalker31, fanWalker41.
+fanWalker61 :: Core.Term -> Maybe Core.Term
+fanWalker61 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker60 fun) (fanWalker60 arg) (\_ -> fanWalker60 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker31 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker41 body) Nothing (\inner -> fanWalker41 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 62; branches to fanWalker61, fanWalker31, fanWalker42.
+fanWalker62 :: Core.Term -> Maybe Core.Term
+fanWalker62 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker61 fun) (fanWalker61 arg) (\_ -> fanWalker61 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker31 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker42 body) Nothing (\inner -> fanWalker42 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 63; branches to fanWalker62, fanWalker32, fanWalker42.
+fanWalker63 :: Core.Term -> Maybe Core.Term
+fanWalker63 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker62 fun) (fanWalker62 arg) (\_ -> fanWalker62 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker32 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker42 body) Nothing (\inner -> fanWalker42 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 64; branches to fanWalker63, fanWalker32, fanWalker43.
+fanWalker64 :: Core.Term -> Maybe Core.Term
+fanWalker64 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker63 fun) (fanWalker63 arg) (\_ -> fanWalker63 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker32 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker43 body) Nothing (\inner -> fanWalker43 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 65; branches to fanWalker64, fanWalker33, fanWalker44.
+fanWalker65 :: Core.Term -> Maybe Core.Term
+fanWalker65 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker64 fun) (fanWalker64 arg) (\_ -> fanWalker64 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker33 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker44 body) Nothing (\inner -> fanWalker44 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 66; branches to fanWalker65, fanWalker33, fanWalker44.
+fanWalker66 :: Core.Term -> Maybe Core.Term
+fanWalker66 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker65 fun) (fanWalker65 arg) (\_ -> fanWalker65 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker33 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker44 body) Nothing (\inner -> fanWalker44 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 67; branches to fanWalker66, fanWalker34, fanWalker45.
+fanWalker67 :: Core.Term -> Maybe Core.Term
+fanWalker67 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker66 fun) (fanWalker66 arg) (\_ -> fanWalker66 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker34 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker45 body) Nothing (\inner -> fanWalker45 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 68; branches to fanWalker67, fanWalker34, fanWalker46.
+fanWalker68 :: Core.Term -> Maybe Core.Term
+fanWalker68 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker67 fun) (fanWalker67 arg) (\_ -> fanWalker67 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker34 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker46 body) Nothing (\inner -> fanWalker46 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 69; branches to fanWalker68, fanWalker35, fanWalker46.
+fanWalker69 :: Core.Term -> Maybe Core.Term
+fanWalker69 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker68 fun) (fanWalker68 arg) (\_ -> fanWalker68 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker35 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker46 body) Nothing (\inner -> fanWalker46 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 7; branches to fanWalker6, fanWalker4, fanWalker5.
+fanWalker7 :: Core.Term -> Maybe Core.Term
+fanWalker7 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker6 fun) (fanWalker6 arg) (\_ -> fanWalker6 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker4 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker5 body) Nothing (\inner -> fanWalker5 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 70; branches to fanWalker69, fanWalker35, fanWalker47.
+fanWalker70 :: Core.Term -> Maybe Core.Term
+fanWalker70 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker69 fun) (fanWalker69 arg) (\_ -> fanWalker69 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker35 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker47 body) Nothing (\inner -> fanWalker47 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 71; branches to fanWalker70, fanWalker36, fanWalker48.
+fanWalker71 :: Core.Term -> Maybe Core.Term
+fanWalker71 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker70 fun) (fanWalker70 arg) (\_ -> fanWalker70 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker36 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker48 body) Nothing (\inner -> fanWalker48 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 72; branches to fanWalker71, fanWalker36, fanWalker48.
+fanWalker72 :: Core.Term -> Maybe Core.Term
+fanWalker72 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker71 fun) (fanWalker71 arg) (\_ -> fanWalker71 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker36 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker48 body) Nothing (\inner -> fanWalker48 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 73; branches to fanWalker72, fanWalker37, fanWalker49.
+fanWalker73 :: Core.Term -> Maybe Core.Term
+fanWalker73 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker72 fun) (fanWalker72 arg) (\_ -> fanWalker72 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker37 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker49 body) Nothing (\inner -> fanWalker49 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 74; branches to fanWalker73, fanWalker37, fanWalker50.
+fanWalker74 :: Core.Term -> Maybe Core.Term
+fanWalker74 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker73 fun) (fanWalker73 arg) (\_ -> fanWalker73 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker37 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker50 body) Nothing (\inner -> fanWalker50 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 75; branches to fanWalker74, fanWalker38, fanWalker50.
+fanWalker75 :: Core.Term -> Maybe Core.Term
+fanWalker75 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker74 fun) (fanWalker74 arg) (\_ -> fanWalker74 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker38 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker50 body) Nothing (\inner -> fanWalker50 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 76; branches to fanWalker75, fanWalker38, fanWalker51.
+fanWalker76 :: Core.Term -> Maybe Core.Term
+fanWalker76 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker75 fun) (fanWalker75 arg) (\_ -> fanWalker75 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker38 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker51 body) Nothing (\inner -> fanWalker51 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 77; branches to fanWalker76, fanWalker39, fanWalker52.
+fanWalker77 :: Core.Term -> Maybe Core.Term
+fanWalker77 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker76 fun) (fanWalker76 arg) (\_ -> fanWalker76 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker39 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker52 body) Nothing (\inner -> fanWalker52 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 78; branches to fanWalker77, fanWalker39, fanWalker52.
+fanWalker78 :: Core.Term -> Maybe Core.Term
+fanWalker78 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker77 fun) (fanWalker77 arg) (\_ -> fanWalker77 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker39 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker52 body) Nothing (\inner -> fanWalker52 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 79; branches to fanWalker78, fanWalker40, fanWalker53.
+fanWalker79 :: Core.Term -> Maybe Core.Term
+fanWalker79 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker78 fun) (fanWalker78 arg) (\_ -> fanWalker78 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker40 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker53 body) Nothing (\inner -> fanWalker53 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 8; branches to fanWalker7, fanWalker4, fanWalker6.
+fanWalker8 :: Core.Term -> Maybe Core.Term
+fanWalker8 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker7 fun) (fanWalker7 arg) (\_ -> fanWalker7 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker4 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker6 body) Nothing (\inner -> fanWalker6 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 80; branches to fanWalker79, fanWalker40, fanWalker54.
+fanWalker80 :: Core.Term -> Maybe Core.Term
+fanWalker80 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker79 fun) (fanWalker79 arg) (\_ -> fanWalker79 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker40 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker54 body) Nothing (\inner -> fanWalker54 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 81; branches to fanWalker80, fanWalker41, fanWalker54.
+fanWalker81 :: Core.Term -> Maybe Core.Term
+fanWalker81 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker80 fun) (fanWalker80 arg) (\_ -> fanWalker80 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker41 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker54 body) Nothing (\inner -> fanWalker54 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 82; branches to fanWalker81, fanWalker41, fanWalker55.
+fanWalker82 :: Core.Term -> Maybe Core.Term
+fanWalker82 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker81 fun) (fanWalker81 arg) (\_ -> fanWalker81 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker41 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker55 body) Nothing (\inner -> fanWalker55 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 83; branches to fanWalker82, fanWalker42, fanWalker56.
+fanWalker83 :: Core.Term -> Maybe Core.Term
+fanWalker83 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker82 fun) (fanWalker82 arg) (\_ -> fanWalker82 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker42 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker56 body) Nothing (\inner -> fanWalker56 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 84; branches to fanWalker83, fanWalker42, fanWalker56.
+fanWalker84 :: Core.Term -> Maybe Core.Term
+fanWalker84 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker83 fun) (fanWalker83 arg) (\_ -> fanWalker83 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker42 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker56 body) Nothing (\inner -> fanWalker56 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 85; branches to fanWalker84, fanWalker43, fanWalker57.
+fanWalker85 :: Core.Term -> Maybe Core.Term
+fanWalker85 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker84 fun) (fanWalker84 arg) (\_ -> fanWalker84 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker43 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker57 body) Nothing (\inner -> fanWalker57 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 86; branches to fanWalker85, fanWalker43, fanWalker58.
+fanWalker86 :: Core.Term -> Maybe Core.Term
+fanWalker86 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker85 fun) (fanWalker85 arg) (\_ -> fanWalker85 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker43 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker58 body) Nothing (\inner -> fanWalker58 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 87; branches to fanWalker86, fanWalker44, fanWalker58.
+fanWalker87 :: Core.Term -> Maybe Core.Term
+fanWalker87 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker86 fun) (fanWalker86 arg) (\_ -> fanWalker86 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker44 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker58 body) Nothing (\inner -> fanWalker58 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 88; branches to fanWalker87, fanWalker44, fanWalker59.
+fanWalker88 :: Core.Term -> Maybe Core.Term
+fanWalker88 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker87 fun) (fanWalker87 arg) (\_ -> fanWalker87 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker44 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker59 body) Nothing (\inner -> fanWalker59 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 89; branches to fanWalker88, fanWalker45, fanWalker60.
+fanWalker89 :: Core.Term -> Maybe Core.Term
+fanWalker89 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker88 fun) (fanWalker88 arg) (\_ -> fanWalker88 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker45 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker60 body) Nothing (\inner -> fanWalker60 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 9; branches to fanWalker8, fanWalker5, fanWalker6.
+fanWalker9 :: Core.Term -> Maybe Core.Term
+fanWalker9 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker8 fun) (fanWalker8 arg) (\_ -> fanWalker8 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker5 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker6 body) Nothing (\inner -> fanWalker6 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 90; branches to fanWalker89, fanWalker45, fanWalker60.
+fanWalker90 :: Core.Term -> Maybe Core.Term
+fanWalker90 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker89 fun) (fanWalker89 arg) (\_ -> fanWalker89 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker45 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker60 body) Nothing (\inner -> fanWalker60 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 91; branches to fanWalker90, fanWalker46, fanWalker61.
+fanWalker91 :: Core.Term -> Maybe Core.Term
+fanWalker91 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker90 fun) (fanWalker90 arg) (\_ -> fanWalker90 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker46 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker61 body) Nothing (\inner -> fanWalker61 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 92; branches to fanWalker91, fanWalker46, fanWalker62.
+fanWalker92 :: Core.Term -> Maybe Core.Term
+fanWalker92 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker91 fun) (fanWalker91 arg) (\_ -> fanWalker91 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker46 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker62 body) Nothing (\inner -> fanWalker62 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 93; branches to fanWalker92, fanWalker47, fanWalker62.
+fanWalker93 :: Core.Term -> Maybe Core.Term
+fanWalker93 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker92 fun) (fanWalker92 arg) (\_ -> fanWalker92 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker47 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker62 body) Nothing (\inner -> fanWalker62 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 94; branches to fanWalker93, fanWalker47, fanWalker63.
+fanWalker94 :: Core.Term -> Maybe Core.Term
+fanWalker94 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker93 fun) (fanWalker93 arg) (\_ -> fanWalker93 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker47 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker63 body) Nothing (\inner -> fanWalker63 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 95; branches to fanWalker94, fanWalker48, fanWalker64.
+fanWalker95 :: Core.Term -> Maybe Core.Term
+fanWalker95 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker94 fun) (fanWalker94 arg) (\_ -> fanWalker94 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker48 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker64 body) Nothing (\inner -> fanWalker64 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 96; branches to fanWalker95, fanWalker48, fanWalker64.
+fanWalker96 :: Core.Term -> Maybe Core.Term
+fanWalker96 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker95 fun) (fanWalker95 arg) (\_ -> fanWalker95 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker48 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker64 body) Nothing (\inner -> fanWalker64 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 97; branches to fanWalker96, fanWalker49, fanWalker65.
+fanWalker97 :: Core.Term -> Maybe Core.Term
+fanWalker97 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker96 fun) (fanWalker96 arg) (\_ -> fanWalker96 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker49 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker65 body) Nothing (\inner -> fanWalker65 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 98; branches to fanWalker97, fanWalker49, fanWalker66.
+fanWalker98 :: Core.Term -> Maybe Core.Term
+fanWalker98 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker97 fun) (fanWalker97 arg) (\_ -> fanWalker97 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker49 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker66 body) Nothing (\inner -> fanWalker66 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Fan-out walker level 99; branches to fanWalker98, fanWalker50, fanWalker66.
+fanWalker99 :: Core.Term -> Maybe Core.Term
+fanWalker99 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (fanWalker98 fun) (fanWalker98 arg) (\_ -> fanWalker98 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (fanWalker50 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (fanWalker66 body) Nothing (\inner -> fanWalker66 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
diff --git a/src/main/haskell/Hydra/Bench/LinearChain.hs b/src/main/haskell/Hydra/Bench/LinearChain.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Bench/LinearChain.hs
@@ -0,0 +1,15214 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | Linear-chain inference benchmark. walkerK cases on _Term variants and recurses to walker(K-1) — depth-N type-resolution stress test.
+
+module Hydra.Bench.LinearChain where
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Strip as Strip
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+-- | Term walker level 0; recurses to walker0.
+walker0 :: t0 -> Maybe t0
+walker0 t = Just t
+-- | Term walker level 1; recurses to walker0.
+walker1 :: Core.Term -> Maybe Core.Term
+walker1 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker0 fun) (walker0 arg) (\_ -> walker0 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker0 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker0 body) Nothing (\inner -> walker0 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 10; recurses to walker9.
+walker10 :: Core.Term -> Maybe Core.Term
+walker10 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker9 fun) (walker9 arg) (\_ -> walker9 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker9 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker9 body) Nothing (\inner -> walker9 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 100; recurses to walker99.
+walker100 :: Core.Term -> Maybe Core.Term
+walker100 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker99 fun) (walker99 arg) (\_ -> walker99 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker99 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker99 body) Nothing (\inner -> walker99 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 101; recurses to walker100.
+walker101 :: Core.Term -> Maybe Core.Term
+walker101 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker100 fun) (walker100 arg) (\_ -> walker100 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker100 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker100 body) Nothing (\inner -> walker100 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 102; recurses to walker101.
+walker102 :: Core.Term -> Maybe Core.Term
+walker102 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker101 fun) (walker101 arg) (\_ -> walker101 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker101 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker101 body) Nothing (\inner -> walker101 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 103; recurses to walker102.
+walker103 :: Core.Term -> Maybe Core.Term
+walker103 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker102 fun) (walker102 arg) (\_ -> walker102 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker102 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker102 body) Nothing (\inner -> walker102 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 104; recurses to walker103.
+walker104 :: Core.Term -> Maybe Core.Term
+walker104 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker103 fun) (walker103 arg) (\_ -> walker103 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker103 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker103 body) Nothing (\inner -> walker103 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 105; recurses to walker104.
+walker105 :: Core.Term -> Maybe Core.Term
+walker105 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker104 fun) (walker104 arg) (\_ -> walker104 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker104 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker104 body) Nothing (\inner -> walker104 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 106; recurses to walker105.
+walker106 :: Core.Term -> Maybe Core.Term
+walker106 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker105 fun) (walker105 arg) (\_ -> walker105 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker105 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker105 body) Nothing (\inner -> walker105 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 107; recurses to walker106.
+walker107 :: Core.Term -> Maybe Core.Term
+walker107 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker106 fun) (walker106 arg) (\_ -> walker106 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker106 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker106 body) Nothing (\inner -> walker106 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 108; recurses to walker107.
+walker108 :: Core.Term -> Maybe Core.Term
+walker108 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker107 fun) (walker107 arg) (\_ -> walker107 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker107 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker107 body) Nothing (\inner -> walker107 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 109; recurses to walker108.
+walker109 :: Core.Term -> Maybe Core.Term
+walker109 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker108 fun) (walker108 arg) (\_ -> walker108 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker108 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker108 body) Nothing (\inner -> walker108 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 11; recurses to walker10.
+walker11 :: Core.Term -> Maybe Core.Term
+walker11 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker10 fun) (walker10 arg) (\_ -> walker10 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker10 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker10 body) Nothing (\inner -> walker10 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 110; recurses to walker109.
+walker110 :: Core.Term -> Maybe Core.Term
+walker110 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker109 fun) (walker109 arg) (\_ -> walker109 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker109 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker109 body) Nothing (\inner -> walker109 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 111; recurses to walker110.
+walker111 :: Core.Term -> Maybe Core.Term
+walker111 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker110 fun) (walker110 arg) (\_ -> walker110 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker110 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker110 body) Nothing (\inner -> walker110 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 112; recurses to walker111.
+walker112 :: Core.Term -> Maybe Core.Term
+walker112 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker111 fun) (walker111 arg) (\_ -> walker111 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker111 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker111 body) Nothing (\inner -> walker111 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 113; recurses to walker112.
+walker113 :: Core.Term -> Maybe Core.Term
+walker113 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker112 fun) (walker112 arg) (\_ -> walker112 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker112 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker112 body) Nothing (\inner -> walker112 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 114; recurses to walker113.
+walker114 :: Core.Term -> Maybe Core.Term
+walker114 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker113 fun) (walker113 arg) (\_ -> walker113 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker113 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker113 body) Nothing (\inner -> walker113 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 115; recurses to walker114.
+walker115 :: Core.Term -> Maybe Core.Term
+walker115 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker114 fun) (walker114 arg) (\_ -> walker114 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker114 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker114 body) Nothing (\inner -> walker114 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 116; recurses to walker115.
+walker116 :: Core.Term -> Maybe Core.Term
+walker116 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker115 fun) (walker115 arg) (\_ -> walker115 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker115 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker115 body) Nothing (\inner -> walker115 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 117; recurses to walker116.
+walker117 :: Core.Term -> Maybe Core.Term
+walker117 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker116 fun) (walker116 arg) (\_ -> walker116 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker116 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker116 body) Nothing (\inner -> walker116 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 118; recurses to walker117.
+walker118 :: Core.Term -> Maybe Core.Term
+walker118 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker117 fun) (walker117 arg) (\_ -> walker117 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker117 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker117 body) Nothing (\inner -> walker117 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 119; recurses to walker118.
+walker119 :: Core.Term -> Maybe Core.Term
+walker119 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker118 fun) (walker118 arg) (\_ -> walker118 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker118 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker118 body) Nothing (\inner -> walker118 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 12; recurses to walker11.
+walker12 :: Core.Term -> Maybe Core.Term
+walker12 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker11 fun) (walker11 arg) (\_ -> walker11 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker11 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker11 body) Nothing (\inner -> walker11 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 120; recurses to walker119.
+walker120 :: Core.Term -> Maybe Core.Term
+walker120 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker119 fun) (walker119 arg) (\_ -> walker119 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker119 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker119 body) Nothing (\inner -> walker119 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 121; recurses to walker120.
+walker121 :: Core.Term -> Maybe Core.Term
+walker121 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker120 fun) (walker120 arg) (\_ -> walker120 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker120 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker120 body) Nothing (\inner -> walker120 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 122; recurses to walker121.
+walker122 :: Core.Term -> Maybe Core.Term
+walker122 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker121 fun) (walker121 arg) (\_ -> walker121 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker121 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker121 body) Nothing (\inner -> walker121 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 123; recurses to walker122.
+walker123 :: Core.Term -> Maybe Core.Term
+walker123 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker122 fun) (walker122 arg) (\_ -> walker122 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker122 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker122 body) Nothing (\inner -> walker122 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 124; recurses to walker123.
+walker124 :: Core.Term -> Maybe Core.Term
+walker124 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker123 fun) (walker123 arg) (\_ -> walker123 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker123 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker123 body) Nothing (\inner -> walker123 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 125; recurses to walker124.
+walker125 :: Core.Term -> Maybe Core.Term
+walker125 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker124 fun) (walker124 arg) (\_ -> walker124 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker124 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker124 body) Nothing (\inner -> walker124 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 126; recurses to walker125.
+walker126 :: Core.Term -> Maybe Core.Term
+walker126 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker125 fun) (walker125 arg) (\_ -> walker125 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker125 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker125 body) Nothing (\inner -> walker125 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 127; recurses to walker126.
+walker127 :: Core.Term -> Maybe Core.Term
+walker127 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker126 fun) (walker126 arg) (\_ -> walker126 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker126 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker126 body) Nothing (\inner -> walker126 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 128; recurses to walker127.
+walker128 :: Core.Term -> Maybe Core.Term
+walker128 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker127 fun) (walker127 arg) (\_ -> walker127 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker127 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker127 body) Nothing (\inner -> walker127 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 129; recurses to walker128.
+walker129 :: Core.Term -> Maybe Core.Term
+walker129 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker128 fun) (walker128 arg) (\_ -> walker128 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker128 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker128 body) Nothing (\inner -> walker128 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 13; recurses to walker12.
+walker13 :: Core.Term -> Maybe Core.Term
+walker13 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker12 fun) (walker12 arg) (\_ -> walker12 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker12 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker12 body) Nothing (\inner -> walker12 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 130; recurses to walker129.
+walker130 :: Core.Term -> Maybe Core.Term
+walker130 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker129 fun) (walker129 arg) (\_ -> walker129 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker129 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker129 body) Nothing (\inner -> walker129 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 131; recurses to walker130.
+walker131 :: Core.Term -> Maybe Core.Term
+walker131 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker130 fun) (walker130 arg) (\_ -> walker130 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker130 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker130 body) Nothing (\inner -> walker130 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 132; recurses to walker131.
+walker132 :: Core.Term -> Maybe Core.Term
+walker132 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker131 fun) (walker131 arg) (\_ -> walker131 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker131 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker131 body) Nothing (\inner -> walker131 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 133; recurses to walker132.
+walker133 :: Core.Term -> Maybe Core.Term
+walker133 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker132 fun) (walker132 arg) (\_ -> walker132 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker132 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker132 body) Nothing (\inner -> walker132 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 134; recurses to walker133.
+walker134 :: Core.Term -> Maybe Core.Term
+walker134 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker133 fun) (walker133 arg) (\_ -> walker133 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker133 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker133 body) Nothing (\inner -> walker133 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 135; recurses to walker134.
+walker135 :: Core.Term -> Maybe Core.Term
+walker135 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker134 fun) (walker134 arg) (\_ -> walker134 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker134 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker134 body) Nothing (\inner -> walker134 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 136; recurses to walker135.
+walker136 :: Core.Term -> Maybe Core.Term
+walker136 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker135 fun) (walker135 arg) (\_ -> walker135 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker135 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker135 body) Nothing (\inner -> walker135 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 137; recurses to walker136.
+walker137 :: Core.Term -> Maybe Core.Term
+walker137 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker136 fun) (walker136 arg) (\_ -> walker136 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker136 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker136 body) Nothing (\inner -> walker136 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 138; recurses to walker137.
+walker138 :: Core.Term -> Maybe Core.Term
+walker138 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker137 fun) (walker137 arg) (\_ -> walker137 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker137 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker137 body) Nothing (\inner -> walker137 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 139; recurses to walker138.
+walker139 :: Core.Term -> Maybe Core.Term
+walker139 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker138 fun) (walker138 arg) (\_ -> walker138 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker138 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker138 body) Nothing (\inner -> walker138 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 14; recurses to walker13.
+walker14 :: Core.Term -> Maybe Core.Term
+walker14 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker13 fun) (walker13 arg) (\_ -> walker13 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker13 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker13 body) Nothing (\inner -> walker13 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 140; recurses to walker139.
+walker140 :: Core.Term -> Maybe Core.Term
+walker140 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker139 fun) (walker139 arg) (\_ -> walker139 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker139 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker139 body) Nothing (\inner -> walker139 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 141; recurses to walker140.
+walker141 :: Core.Term -> Maybe Core.Term
+walker141 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker140 fun) (walker140 arg) (\_ -> walker140 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker140 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker140 body) Nothing (\inner -> walker140 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 142; recurses to walker141.
+walker142 :: Core.Term -> Maybe Core.Term
+walker142 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker141 fun) (walker141 arg) (\_ -> walker141 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker141 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker141 body) Nothing (\inner -> walker141 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 143; recurses to walker142.
+walker143 :: Core.Term -> Maybe Core.Term
+walker143 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker142 fun) (walker142 arg) (\_ -> walker142 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker142 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker142 body) Nothing (\inner -> walker142 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 144; recurses to walker143.
+walker144 :: Core.Term -> Maybe Core.Term
+walker144 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker143 fun) (walker143 arg) (\_ -> walker143 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker143 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker143 body) Nothing (\inner -> walker143 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 145; recurses to walker144.
+walker145 :: Core.Term -> Maybe Core.Term
+walker145 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker144 fun) (walker144 arg) (\_ -> walker144 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker144 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker144 body) Nothing (\inner -> walker144 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 146; recurses to walker145.
+walker146 :: Core.Term -> Maybe Core.Term
+walker146 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker145 fun) (walker145 arg) (\_ -> walker145 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker145 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker145 body) Nothing (\inner -> walker145 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 147; recurses to walker146.
+walker147 :: Core.Term -> Maybe Core.Term
+walker147 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker146 fun) (walker146 arg) (\_ -> walker146 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker146 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker146 body) Nothing (\inner -> walker146 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 148; recurses to walker147.
+walker148 :: Core.Term -> Maybe Core.Term
+walker148 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker147 fun) (walker147 arg) (\_ -> walker147 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker147 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker147 body) Nothing (\inner -> walker147 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 149; recurses to walker148.
+walker149 :: Core.Term -> Maybe Core.Term
+walker149 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker148 fun) (walker148 arg) (\_ -> walker148 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker148 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker148 body) Nothing (\inner -> walker148 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 15; recurses to walker14.
+walker15 :: Core.Term -> Maybe Core.Term
+walker15 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker14 fun) (walker14 arg) (\_ -> walker14 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker14 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker14 body) Nothing (\inner -> walker14 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 150; recurses to walker149.
+walker150 :: Core.Term -> Maybe Core.Term
+walker150 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker149 fun) (walker149 arg) (\_ -> walker149 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker149 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker149 body) Nothing (\inner -> walker149 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 151; recurses to walker150.
+walker151 :: Core.Term -> Maybe Core.Term
+walker151 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker150 fun) (walker150 arg) (\_ -> walker150 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker150 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker150 body) Nothing (\inner -> walker150 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 152; recurses to walker151.
+walker152 :: Core.Term -> Maybe Core.Term
+walker152 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker151 fun) (walker151 arg) (\_ -> walker151 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker151 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker151 body) Nothing (\inner -> walker151 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 153; recurses to walker152.
+walker153 :: Core.Term -> Maybe Core.Term
+walker153 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker152 fun) (walker152 arg) (\_ -> walker152 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker152 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker152 body) Nothing (\inner -> walker152 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 154; recurses to walker153.
+walker154 :: Core.Term -> Maybe Core.Term
+walker154 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker153 fun) (walker153 arg) (\_ -> walker153 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker153 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker153 body) Nothing (\inner -> walker153 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 155; recurses to walker154.
+walker155 :: Core.Term -> Maybe Core.Term
+walker155 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker154 fun) (walker154 arg) (\_ -> walker154 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker154 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker154 body) Nothing (\inner -> walker154 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 156; recurses to walker155.
+walker156 :: Core.Term -> Maybe Core.Term
+walker156 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker155 fun) (walker155 arg) (\_ -> walker155 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker155 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker155 body) Nothing (\inner -> walker155 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 157; recurses to walker156.
+walker157 :: Core.Term -> Maybe Core.Term
+walker157 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker156 fun) (walker156 arg) (\_ -> walker156 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker156 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker156 body) Nothing (\inner -> walker156 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 158; recurses to walker157.
+walker158 :: Core.Term -> Maybe Core.Term
+walker158 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker157 fun) (walker157 arg) (\_ -> walker157 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker157 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker157 body) Nothing (\inner -> walker157 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 159; recurses to walker158.
+walker159 :: Core.Term -> Maybe Core.Term
+walker159 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker158 fun) (walker158 arg) (\_ -> walker158 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker158 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker158 body) Nothing (\inner -> walker158 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 16; recurses to walker15.
+walker16 :: Core.Term -> Maybe Core.Term
+walker16 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker15 fun) (walker15 arg) (\_ -> walker15 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker15 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker15 body) Nothing (\inner -> walker15 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 160; recurses to walker159.
+walker160 :: Core.Term -> Maybe Core.Term
+walker160 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker159 fun) (walker159 arg) (\_ -> walker159 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker159 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker159 body) Nothing (\inner -> walker159 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 161; recurses to walker160.
+walker161 :: Core.Term -> Maybe Core.Term
+walker161 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker160 fun) (walker160 arg) (\_ -> walker160 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker160 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker160 body) Nothing (\inner -> walker160 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 162; recurses to walker161.
+walker162 :: Core.Term -> Maybe Core.Term
+walker162 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker161 fun) (walker161 arg) (\_ -> walker161 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker161 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker161 body) Nothing (\inner -> walker161 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 163; recurses to walker162.
+walker163 :: Core.Term -> Maybe Core.Term
+walker163 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker162 fun) (walker162 arg) (\_ -> walker162 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker162 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker162 body) Nothing (\inner -> walker162 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 164; recurses to walker163.
+walker164 :: Core.Term -> Maybe Core.Term
+walker164 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker163 fun) (walker163 arg) (\_ -> walker163 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker163 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker163 body) Nothing (\inner -> walker163 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 165; recurses to walker164.
+walker165 :: Core.Term -> Maybe Core.Term
+walker165 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker164 fun) (walker164 arg) (\_ -> walker164 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker164 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker164 body) Nothing (\inner -> walker164 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 166; recurses to walker165.
+walker166 :: Core.Term -> Maybe Core.Term
+walker166 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker165 fun) (walker165 arg) (\_ -> walker165 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker165 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker165 body) Nothing (\inner -> walker165 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 167; recurses to walker166.
+walker167 :: Core.Term -> Maybe Core.Term
+walker167 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker166 fun) (walker166 arg) (\_ -> walker166 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker166 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker166 body) Nothing (\inner -> walker166 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 168; recurses to walker167.
+walker168 :: Core.Term -> Maybe Core.Term
+walker168 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker167 fun) (walker167 arg) (\_ -> walker167 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker167 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker167 body) Nothing (\inner -> walker167 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 169; recurses to walker168.
+walker169 :: Core.Term -> Maybe Core.Term
+walker169 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker168 fun) (walker168 arg) (\_ -> walker168 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker168 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker168 body) Nothing (\inner -> walker168 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 17; recurses to walker16.
+walker17 :: Core.Term -> Maybe Core.Term
+walker17 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker16 fun) (walker16 arg) (\_ -> walker16 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker16 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker16 body) Nothing (\inner -> walker16 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 170; recurses to walker169.
+walker170 :: Core.Term -> Maybe Core.Term
+walker170 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker169 fun) (walker169 arg) (\_ -> walker169 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker169 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker169 body) Nothing (\inner -> walker169 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 171; recurses to walker170.
+walker171 :: Core.Term -> Maybe Core.Term
+walker171 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker170 fun) (walker170 arg) (\_ -> walker170 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker170 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker170 body) Nothing (\inner -> walker170 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 172; recurses to walker171.
+walker172 :: Core.Term -> Maybe Core.Term
+walker172 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker171 fun) (walker171 arg) (\_ -> walker171 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker171 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker171 body) Nothing (\inner -> walker171 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 173; recurses to walker172.
+walker173 :: Core.Term -> Maybe Core.Term
+walker173 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker172 fun) (walker172 arg) (\_ -> walker172 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker172 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker172 body) Nothing (\inner -> walker172 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 174; recurses to walker173.
+walker174 :: Core.Term -> Maybe Core.Term
+walker174 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker173 fun) (walker173 arg) (\_ -> walker173 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker173 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker173 body) Nothing (\inner -> walker173 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 175; recurses to walker174.
+walker175 :: Core.Term -> Maybe Core.Term
+walker175 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker174 fun) (walker174 arg) (\_ -> walker174 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker174 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker174 body) Nothing (\inner -> walker174 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 176; recurses to walker175.
+walker176 :: Core.Term -> Maybe Core.Term
+walker176 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker175 fun) (walker175 arg) (\_ -> walker175 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker175 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker175 body) Nothing (\inner -> walker175 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 177; recurses to walker176.
+walker177 :: Core.Term -> Maybe Core.Term
+walker177 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker176 fun) (walker176 arg) (\_ -> walker176 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker176 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker176 body) Nothing (\inner -> walker176 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 178; recurses to walker177.
+walker178 :: Core.Term -> Maybe Core.Term
+walker178 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker177 fun) (walker177 arg) (\_ -> walker177 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker177 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker177 body) Nothing (\inner -> walker177 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 179; recurses to walker178.
+walker179 :: Core.Term -> Maybe Core.Term
+walker179 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker178 fun) (walker178 arg) (\_ -> walker178 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker178 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker178 body) Nothing (\inner -> walker178 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 18; recurses to walker17.
+walker18 :: Core.Term -> Maybe Core.Term
+walker18 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker17 fun) (walker17 arg) (\_ -> walker17 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker17 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker17 body) Nothing (\inner -> walker17 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 180; recurses to walker179.
+walker180 :: Core.Term -> Maybe Core.Term
+walker180 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker179 fun) (walker179 arg) (\_ -> walker179 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker179 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker179 body) Nothing (\inner -> walker179 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 181; recurses to walker180.
+walker181 :: Core.Term -> Maybe Core.Term
+walker181 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker180 fun) (walker180 arg) (\_ -> walker180 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker180 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker180 body) Nothing (\inner -> walker180 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 182; recurses to walker181.
+walker182 :: Core.Term -> Maybe Core.Term
+walker182 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker181 fun) (walker181 arg) (\_ -> walker181 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker181 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker181 body) Nothing (\inner -> walker181 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 183; recurses to walker182.
+walker183 :: Core.Term -> Maybe Core.Term
+walker183 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker182 fun) (walker182 arg) (\_ -> walker182 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker182 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker182 body) Nothing (\inner -> walker182 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 184; recurses to walker183.
+walker184 :: Core.Term -> Maybe Core.Term
+walker184 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker183 fun) (walker183 arg) (\_ -> walker183 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker183 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker183 body) Nothing (\inner -> walker183 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 185; recurses to walker184.
+walker185 :: Core.Term -> Maybe Core.Term
+walker185 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker184 fun) (walker184 arg) (\_ -> walker184 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker184 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker184 body) Nothing (\inner -> walker184 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 186; recurses to walker185.
+walker186 :: Core.Term -> Maybe Core.Term
+walker186 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker185 fun) (walker185 arg) (\_ -> walker185 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker185 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker185 body) Nothing (\inner -> walker185 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 187; recurses to walker186.
+walker187 :: Core.Term -> Maybe Core.Term
+walker187 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker186 fun) (walker186 arg) (\_ -> walker186 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker186 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker186 body) Nothing (\inner -> walker186 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 188; recurses to walker187.
+walker188 :: Core.Term -> Maybe Core.Term
+walker188 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker187 fun) (walker187 arg) (\_ -> walker187 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker187 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker187 body) Nothing (\inner -> walker187 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 189; recurses to walker188.
+walker189 :: Core.Term -> Maybe Core.Term
+walker189 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker188 fun) (walker188 arg) (\_ -> walker188 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker188 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker188 body) Nothing (\inner -> walker188 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 19; recurses to walker18.
+walker19 :: Core.Term -> Maybe Core.Term
+walker19 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker18 fun) (walker18 arg) (\_ -> walker18 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker18 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker18 body) Nothing (\inner -> walker18 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 190; recurses to walker189.
+walker190 :: Core.Term -> Maybe Core.Term
+walker190 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker189 fun) (walker189 arg) (\_ -> walker189 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker189 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker189 body) Nothing (\inner -> walker189 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 191; recurses to walker190.
+walker191 :: Core.Term -> Maybe Core.Term
+walker191 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker190 fun) (walker190 arg) (\_ -> walker190 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker190 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker190 body) Nothing (\inner -> walker190 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 192; recurses to walker191.
+walker192 :: Core.Term -> Maybe Core.Term
+walker192 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker191 fun) (walker191 arg) (\_ -> walker191 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker191 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker191 body) Nothing (\inner -> walker191 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 193; recurses to walker192.
+walker193 :: Core.Term -> Maybe Core.Term
+walker193 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker192 fun) (walker192 arg) (\_ -> walker192 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker192 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker192 body) Nothing (\inner -> walker192 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 194; recurses to walker193.
+walker194 :: Core.Term -> Maybe Core.Term
+walker194 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker193 fun) (walker193 arg) (\_ -> walker193 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker193 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker193 body) Nothing (\inner -> walker193 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 195; recurses to walker194.
+walker195 :: Core.Term -> Maybe Core.Term
+walker195 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker194 fun) (walker194 arg) (\_ -> walker194 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker194 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker194 body) Nothing (\inner -> walker194 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 196; recurses to walker195.
+walker196 :: Core.Term -> Maybe Core.Term
+walker196 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker195 fun) (walker195 arg) (\_ -> walker195 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker195 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker195 body) Nothing (\inner -> walker195 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 197; recurses to walker196.
+walker197 :: Core.Term -> Maybe Core.Term
+walker197 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker196 fun) (walker196 arg) (\_ -> walker196 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker196 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker196 body) Nothing (\inner -> walker196 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 198; recurses to walker197.
+walker198 :: Core.Term -> Maybe Core.Term
+walker198 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker197 fun) (walker197 arg) (\_ -> walker197 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker197 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker197 body) Nothing (\inner -> walker197 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 199; recurses to walker198.
+walker199 :: Core.Term -> Maybe Core.Term
+walker199 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker198 fun) (walker198 arg) (\_ -> walker198 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker198 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker198 body) Nothing (\inner -> walker198 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 2; recurses to walker1.
+walker2 :: Core.Term -> Maybe Core.Term
+walker2 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker1 fun) (walker1 arg) (\_ -> walker1 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker1 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker1 body) Nothing (\inner -> walker1 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 20; recurses to walker19.
+walker20 :: Core.Term -> Maybe Core.Term
+walker20 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker19 fun) (walker19 arg) (\_ -> walker19 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker19 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker19 body) Nothing (\inner -> walker19 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 200; recurses to walker199.
+walker200 :: Core.Term -> Maybe Core.Term
+walker200 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker199 fun) (walker199 arg) (\_ -> walker199 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker199 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker199 body) Nothing (\inner -> walker199 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 201; recurses to walker200.
+walker201 :: Core.Term -> Maybe Core.Term
+walker201 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker200 fun) (walker200 arg) (\_ -> walker200 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker200 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker200 body) Nothing (\inner -> walker200 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 202; recurses to walker201.
+walker202 :: Core.Term -> Maybe Core.Term
+walker202 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker201 fun) (walker201 arg) (\_ -> walker201 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker201 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker201 body) Nothing (\inner -> walker201 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 203; recurses to walker202.
+walker203 :: Core.Term -> Maybe Core.Term
+walker203 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker202 fun) (walker202 arg) (\_ -> walker202 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker202 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker202 body) Nothing (\inner -> walker202 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 204; recurses to walker203.
+walker204 :: Core.Term -> Maybe Core.Term
+walker204 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker203 fun) (walker203 arg) (\_ -> walker203 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker203 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker203 body) Nothing (\inner -> walker203 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 205; recurses to walker204.
+walker205 :: Core.Term -> Maybe Core.Term
+walker205 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker204 fun) (walker204 arg) (\_ -> walker204 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker204 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker204 body) Nothing (\inner -> walker204 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 206; recurses to walker205.
+walker206 :: Core.Term -> Maybe Core.Term
+walker206 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker205 fun) (walker205 arg) (\_ -> walker205 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker205 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker205 body) Nothing (\inner -> walker205 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 207; recurses to walker206.
+walker207 :: Core.Term -> Maybe Core.Term
+walker207 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker206 fun) (walker206 arg) (\_ -> walker206 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker206 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker206 body) Nothing (\inner -> walker206 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 208; recurses to walker207.
+walker208 :: Core.Term -> Maybe Core.Term
+walker208 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker207 fun) (walker207 arg) (\_ -> walker207 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker207 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker207 body) Nothing (\inner -> walker207 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 209; recurses to walker208.
+walker209 :: Core.Term -> Maybe Core.Term
+walker209 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker208 fun) (walker208 arg) (\_ -> walker208 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker208 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker208 body) Nothing (\inner -> walker208 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 21; recurses to walker20.
+walker21 :: Core.Term -> Maybe Core.Term
+walker21 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker20 fun) (walker20 arg) (\_ -> walker20 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker20 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker20 body) Nothing (\inner -> walker20 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 210; recurses to walker209.
+walker210 :: Core.Term -> Maybe Core.Term
+walker210 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker209 fun) (walker209 arg) (\_ -> walker209 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker209 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker209 body) Nothing (\inner -> walker209 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 211; recurses to walker210.
+walker211 :: Core.Term -> Maybe Core.Term
+walker211 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker210 fun) (walker210 arg) (\_ -> walker210 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker210 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker210 body) Nothing (\inner -> walker210 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 212; recurses to walker211.
+walker212 :: Core.Term -> Maybe Core.Term
+walker212 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker211 fun) (walker211 arg) (\_ -> walker211 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker211 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker211 body) Nothing (\inner -> walker211 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 213; recurses to walker212.
+walker213 :: Core.Term -> Maybe Core.Term
+walker213 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker212 fun) (walker212 arg) (\_ -> walker212 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker212 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker212 body) Nothing (\inner -> walker212 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 214; recurses to walker213.
+walker214 :: Core.Term -> Maybe Core.Term
+walker214 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker213 fun) (walker213 arg) (\_ -> walker213 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker213 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker213 body) Nothing (\inner -> walker213 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 215; recurses to walker214.
+walker215 :: Core.Term -> Maybe Core.Term
+walker215 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker214 fun) (walker214 arg) (\_ -> walker214 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker214 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker214 body) Nothing (\inner -> walker214 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 216; recurses to walker215.
+walker216 :: Core.Term -> Maybe Core.Term
+walker216 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker215 fun) (walker215 arg) (\_ -> walker215 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker215 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker215 body) Nothing (\inner -> walker215 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 217; recurses to walker216.
+walker217 :: Core.Term -> Maybe Core.Term
+walker217 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker216 fun) (walker216 arg) (\_ -> walker216 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker216 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker216 body) Nothing (\inner -> walker216 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 218; recurses to walker217.
+walker218 :: Core.Term -> Maybe Core.Term
+walker218 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker217 fun) (walker217 arg) (\_ -> walker217 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker217 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker217 body) Nothing (\inner -> walker217 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 219; recurses to walker218.
+walker219 :: Core.Term -> Maybe Core.Term
+walker219 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker218 fun) (walker218 arg) (\_ -> walker218 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker218 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker218 body) Nothing (\inner -> walker218 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 22; recurses to walker21.
+walker22 :: Core.Term -> Maybe Core.Term
+walker22 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker21 fun) (walker21 arg) (\_ -> walker21 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker21 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker21 body) Nothing (\inner -> walker21 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 220; recurses to walker219.
+walker220 :: Core.Term -> Maybe Core.Term
+walker220 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker219 fun) (walker219 arg) (\_ -> walker219 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker219 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker219 body) Nothing (\inner -> walker219 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 221; recurses to walker220.
+walker221 :: Core.Term -> Maybe Core.Term
+walker221 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker220 fun) (walker220 arg) (\_ -> walker220 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker220 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker220 body) Nothing (\inner -> walker220 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 222; recurses to walker221.
+walker222 :: Core.Term -> Maybe Core.Term
+walker222 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker221 fun) (walker221 arg) (\_ -> walker221 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker221 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker221 body) Nothing (\inner -> walker221 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 223; recurses to walker222.
+walker223 :: Core.Term -> Maybe Core.Term
+walker223 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker222 fun) (walker222 arg) (\_ -> walker222 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker222 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker222 body) Nothing (\inner -> walker222 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 224; recurses to walker223.
+walker224 :: Core.Term -> Maybe Core.Term
+walker224 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker223 fun) (walker223 arg) (\_ -> walker223 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker223 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker223 body) Nothing (\inner -> walker223 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 225; recurses to walker224.
+walker225 :: Core.Term -> Maybe Core.Term
+walker225 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker224 fun) (walker224 arg) (\_ -> walker224 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker224 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker224 body) Nothing (\inner -> walker224 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 226; recurses to walker225.
+walker226 :: Core.Term -> Maybe Core.Term
+walker226 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker225 fun) (walker225 arg) (\_ -> walker225 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker225 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker225 body) Nothing (\inner -> walker225 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 227; recurses to walker226.
+walker227 :: Core.Term -> Maybe Core.Term
+walker227 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker226 fun) (walker226 arg) (\_ -> walker226 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker226 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker226 body) Nothing (\inner -> walker226 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 228; recurses to walker227.
+walker228 :: Core.Term -> Maybe Core.Term
+walker228 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker227 fun) (walker227 arg) (\_ -> walker227 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker227 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker227 body) Nothing (\inner -> walker227 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 229; recurses to walker228.
+walker229 :: Core.Term -> Maybe Core.Term
+walker229 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker228 fun) (walker228 arg) (\_ -> walker228 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker228 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker228 body) Nothing (\inner -> walker228 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 23; recurses to walker22.
+walker23 :: Core.Term -> Maybe Core.Term
+walker23 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker22 fun) (walker22 arg) (\_ -> walker22 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker22 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker22 body) Nothing (\inner -> walker22 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 230; recurses to walker229.
+walker230 :: Core.Term -> Maybe Core.Term
+walker230 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker229 fun) (walker229 arg) (\_ -> walker229 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker229 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker229 body) Nothing (\inner -> walker229 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 231; recurses to walker230.
+walker231 :: Core.Term -> Maybe Core.Term
+walker231 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker230 fun) (walker230 arg) (\_ -> walker230 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker230 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker230 body) Nothing (\inner -> walker230 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 232; recurses to walker231.
+walker232 :: Core.Term -> Maybe Core.Term
+walker232 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker231 fun) (walker231 arg) (\_ -> walker231 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker231 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker231 body) Nothing (\inner -> walker231 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 233; recurses to walker232.
+walker233 :: Core.Term -> Maybe Core.Term
+walker233 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker232 fun) (walker232 arg) (\_ -> walker232 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker232 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker232 body) Nothing (\inner -> walker232 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 234; recurses to walker233.
+walker234 :: Core.Term -> Maybe Core.Term
+walker234 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker233 fun) (walker233 arg) (\_ -> walker233 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker233 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker233 body) Nothing (\inner -> walker233 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 235; recurses to walker234.
+walker235 :: Core.Term -> Maybe Core.Term
+walker235 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker234 fun) (walker234 arg) (\_ -> walker234 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker234 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker234 body) Nothing (\inner -> walker234 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 236; recurses to walker235.
+walker236 :: Core.Term -> Maybe Core.Term
+walker236 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker235 fun) (walker235 arg) (\_ -> walker235 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker235 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker235 body) Nothing (\inner -> walker235 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 237; recurses to walker236.
+walker237 :: Core.Term -> Maybe Core.Term
+walker237 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker236 fun) (walker236 arg) (\_ -> walker236 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker236 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker236 body) Nothing (\inner -> walker236 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 238; recurses to walker237.
+walker238 :: Core.Term -> Maybe Core.Term
+walker238 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker237 fun) (walker237 arg) (\_ -> walker237 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker237 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker237 body) Nothing (\inner -> walker237 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 239; recurses to walker238.
+walker239 :: Core.Term -> Maybe Core.Term
+walker239 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker238 fun) (walker238 arg) (\_ -> walker238 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker238 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker238 body) Nothing (\inner -> walker238 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 24; recurses to walker23.
+walker24 :: Core.Term -> Maybe Core.Term
+walker24 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker23 fun) (walker23 arg) (\_ -> walker23 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker23 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker23 body) Nothing (\inner -> walker23 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 240; recurses to walker239.
+walker240 :: Core.Term -> Maybe Core.Term
+walker240 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker239 fun) (walker239 arg) (\_ -> walker239 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker239 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker239 body) Nothing (\inner -> walker239 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 241; recurses to walker240.
+walker241 :: Core.Term -> Maybe Core.Term
+walker241 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker240 fun) (walker240 arg) (\_ -> walker240 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker240 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker240 body) Nothing (\inner -> walker240 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 242; recurses to walker241.
+walker242 :: Core.Term -> Maybe Core.Term
+walker242 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker241 fun) (walker241 arg) (\_ -> walker241 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker241 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker241 body) Nothing (\inner -> walker241 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 243; recurses to walker242.
+walker243 :: Core.Term -> Maybe Core.Term
+walker243 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker242 fun) (walker242 arg) (\_ -> walker242 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker242 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker242 body) Nothing (\inner -> walker242 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 244; recurses to walker243.
+walker244 :: Core.Term -> Maybe Core.Term
+walker244 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker243 fun) (walker243 arg) (\_ -> walker243 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker243 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker243 body) Nothing (\inner -> walker243 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 245; recurses to walker244.
+walker245 :: Core.Term -> Maybe Core.Term
+walker245 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker244 fun) (walker244 arg) (\_ -> walker244 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker244 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker244 body) Nothing (\inner -> walker244 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 246; recurses to walker245.
+walker246 :: Core.Term -> Maybe Core.Term
+walker246 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker245 fun) (walker245 arg) (\_ -> walker245 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker245 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker245 body) Nothing (\inner -> walker245 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 247; recurses to walker246.
+walker247 :: Core.Term -> Maybe Core.Term
+walker247 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker246 fun) (walker246 arg) (\_ -> walker246 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker246 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker246 body) Nothing (\inner -> walker246 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 248; recurses to walker247.
+walker248 :: Core.Term -> Maybe Core.Term
+walker248 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker247 fun) (walker247 arg) (\_ -> walker247 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker247 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker247 body) Nothing (\inner -> walker247 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 249; recurses to walker248.
+walker249 :: Core.Term -> Maybe Core.Term
+walker249 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker248 fun) (walker248 arg) (\_ -> walker248 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker248 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker248 body) Nothing (\inner -> walker248 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 25; recurses to walker24.
+walker25 :: Core.Term -> Maybe Core.Term
+walker25 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker24 fun) (walker24 arg) (\_ -> walker24 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker24 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker24 body) Nothing (\inner -> walker24 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 250; recurses to walker249.
+walker250 :: Core.Term -> Maybe Core.Term
+walker250 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker249 fun) (walker249 arg) (\_ -> walker249 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker249 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker249 body) Nothing (\inner -> walker249 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 251; recurses to walker250.
+walker251 :: Core.Term -> Maybe Core.Term
+walker251 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker250 fun) (walker250 arg) (\_ -> walker250 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker250 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker250 body) Nothing (\inner -> walker250 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 252; recurses to walker251.
+walker252 :: Core.Term -> Maybe Core.Term
+walker252 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker251 fun) (walker251 arg) (\_ -> walker251 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker251 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker251 body) Nothing (\inner -> walker251 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 253; recurses to walker252.
+walker253 :: Core.Term -> Maybe Core.Term
+walker253 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker252 fun) (walker252 arg) (\_ -> walker252 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker252 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker252 body) Nothing (\inner -> walker252 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 254; recurses to walker253.
+walker254 :: Core.Term -> Maybe Core.Term
+walker254 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker253 fun) (walker253 arg) (\_ -> walker253 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker253 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker253 body) Nothing (\inner -> walker253 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 255; recurses to walker254.
+walker255 :: Core.Term -> Maybe Core.Term
+walker255 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker254 fun) (walker254 arg) (\_ -> walker254 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker254 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker254 body) Nothing (\inner -> walker254 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 256; recurses to walker255.
+walker256 :: Core.Term -> Maybe Core.Term
+walker256 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker255 fun) (walker255 arg) (\_ -> walker255 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker255 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker255 body) Nothing (\inner -> walker255 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 257; recurses to walker256.
+walker257 :: Core.Term -> Maybe Core.Term
+walker257 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker256 fun) (walker256 arg) (\_ -> walker256 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker256 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker256 body) Nothing (\inner -> walker256 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 258; recurses to walker257.
+walker258 :: Core.Term -> Maybe Core.Term
+walker258 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker257 fun) (walker257 arg) (\_ -> walker257 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker257 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker257 body) Nothing (\inner -> walker257 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 259; recurses to walker258.
+walker259 :: Core.Term -> Maybe Core.Term
+walker259 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker258 fun) (walker258 arg) (\_ -> walker258 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker258 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker258 body) Nothing (\inner -> walker258 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 26; recurses to walker25.
+walker26 :: Core.Term -> Maybe Core.Term
+walker26 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker25 fun) (walker25 arg) (\_ -> walker25 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker25 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker25 body) Nothing (\inner -> walker25 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 260; recurses to walker259.
+walker260 :: Core.Term -> Maybe Core.Term
+walker260 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker259 fun) (walker259 arg) (\_ -> walker259 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker259 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker259 body) Nothing (\inner -> walker259 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 261; recurses to walker260.
+walker261 :: Core.Term -> Maybe Core.Term
+walker261 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker260 fun) (walker260 arg) (\_ -> walker260 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker260 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker260 body) Nothing (\inner -> walker260 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 262; recurses to walker261.
+walker262 :: Core.Term -> Maybe Core.Term
+walker262 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker261 fun) (walker261 arg) (\_ -> walker261 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker261 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker261 body) Nothing (\inner -> walker261 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 263; recurses to walker262.
+walker263 :: Core.Term -> Maybe Core.Term
+walker263 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker262 fun) (walker262 arg) (\_ -> walker262 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker262 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker262 body) Nothing (\inner -> walker262 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 264; recurses to walker263.
+walker264 :: Core.Term -> Maybe Core.Term
+walker264 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker263 fun) (walker263 arg) (\_ -> walker263 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker263 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker263 body) Nothing (\inner -> walker263 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 265; recurses to walker264.
+walker265 :: Core.Term -> Maybe Core.Term
+walker265 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker264 fun) (walker264 arg) (\_ -> walker264 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker264 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker264 body) Nothing (\inner -> walker264 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 266; recurses to walker265.
+walker266 :: Core.Term -> Maybe Core.Term
+walker266 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker265 fun) (walker265 arg) (\_ -> walker265 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker265 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker265 body) Nothing (\inner -> walker265 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 267; recurses to walker266.
+walker267 :: Core.Term -> Maybe Core.Term
+walker267 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker266 fun) (walker266 arg) (\_ -> walker266 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker266 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker266 body) Nothing (\inner -> walker266 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 268; recurses to walker267.
+walker268 :: Core.Term -> Maybe Core.Term
+walker268 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker267 fun) (walker267 arg) (\_ -> walker267 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker267 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker267 body) Nothing (\inner -> walker267 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 269; recurses to walker268.
+walker269 :: Core.Term -> Maybe Core.Term
+walker269 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker268 fun) (walker268 arg) (\_ -> walker268 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker268 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker268 body) Nothing (\inner -> walker268 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 27; recurses to walker26.
+walker27 :: Core.Term -> Maybe Core.Term
+walker27 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker26 fun) (walker26 arg) (\_ -> walker26 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker26 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker26 body) Nothing (\inner -> walker26 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 270; recurses to walker269.
+walker270 :: Core.Term -> Maybe Core.Term
+walker270 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker269 fun) (walker269 arg) (\_ -> walker269 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker269 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker269 body) Nothing (\inner -> walker269 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 271; recurses to walker270.
+walker271 :: Core.Term -> Maybe Core.Term
+walker271 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker270 fun) (walker270 arg) (\_ -> walker270 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker270 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker270 body) Nothing (\inner -> walker270 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 272; recurses to walker271.
+walker272 :: Core.Term -> Maybe Core.Term
+walker272 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker271 fun) (walker271 arg) (\_ -> walker271 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker271 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker271 body) Nothing (\inner -> walker271 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 273; recurses to walker272.
+walker273 :: Core.Term -> Maybe Core.Term
+walker273 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker272 fun) (walker272 arg) (\_ -> walker272 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker272 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker272 body) Nothing (\inner -> walker272 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 274; recurses to walker273.
+walker274 :: Core.Term -> Maybe Core.Term
+walker274 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker273 fun) (walker273 arg) (\_ -> walker273 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker273 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker273 body) Nothing (\inner -> walker273 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 275; recurses to walker274.
+walker275 :: Core.Term -> Maybe Core.Term
+walker275 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker274 fun) (walker274 arg) (\_ -> walker274 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker274 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker274 body) Nothing (\inner -> walker274 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 276; recurses to walker275.
+walker276 :: Core.Term -> Maybe Core.Term
+walker276 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker275 fun) (walker275 arg) (\_ -> walker275 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker275 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker275 body) Nothing (\inner -> walker275 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 277; recurses to walker276.
+walker277 :: Core.Term -> Maybe Core.Term
+walker277 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker276 fun) (walker276 arg) (\_ -> walker276 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker276 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker276 body) Nothing (\inner -> walker276 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 278; recurses to walker277.
+walker278 :: Core.Term -> Maybe Core.Term
+walker278 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker277 fun) (walker277 arg) (\_ -> walker277 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker277 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker277 body) Nothing (\inner -> walker277 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 279; recurses to walker278.
+walker279 :: Core.Term -> Maybe Core.Term
+walker279 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker278 fun) (walker278 arg) (\_ -> walker278 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker278 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker278 body) Nothing (\inner -> walker278 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 28; recurses to walker27.
+walker28 :: Core.Term -> Maybe Core.Term
+walker28 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker27 fun) (walker27 arg) (\_ -> walker27 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker27 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker27 body) Nothing (\inner -> walker27 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 280; recurses to walker279.
+walker280 :: Core.Term -> Maybe Core.Term
+walker280 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker279 fun) (walker279 arg) (\_ -> walker279 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker279 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker279 body) Nothing (\inner -> walker279 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 281; recurses to walker280.
+walker281 :: Core.Term -> Maybe Core.Term
+walker281 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker280 fun) (walker280 arg) (\_ -> walker280 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker280 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker280 body) Nothing (\inner -> walker280 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 282; recurses to walker281.
+walker282 :: Core.Term -> Maybe Core.Term
+walker282 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker281 fun) (walker281 arg) (\_ -> walker281 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker281 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker281 body) Nothing (\inner -> walker281 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 283; recurses to walker282.
+walker283 :: Core.Term -> Maybe Core.Term
+walker283 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker282 fun) (walker282 arg) (\_ -> walker282 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker282 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker282 body) Nothing (\inner -> walker282 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 284; recurses to walker283.
+walker284 :: Core.Term -> Maybe Core.Term
+walker284 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker283 fun) (walker283 arg) (\_ -> walker283 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker283 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker283 body) Nothing (\inner -> walker283 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 285; recurses to walker284.
+walker285 :: Core.Term -> Maybe Core.Term
+walker285 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker284 fun) (walker284 arg) (\_ -> walker284 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker284 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker284 body) Nothing (\inner -> walker284 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 286; recurses to walker285.
+walker286 :: Core.Term -> Maybe Core.Term
+walker286 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker285 fun) (walker285 arg) (\_ -> walker285 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker285 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker285 body) Nothing (\inner -> walker285 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 287; recurses to walker286.
+walker287 :: Core.Term -> Maybe Core.Term
+walker287 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker286 fun) (walker286 arg) (\_ -> walker286 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker286 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker286 body) Nothing (\inner -> walker286 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 288; recurses to walker287.
+walker288 :: Core.Term -> Maybe Core.Term
+walker288 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker287 fun) (walker287 arg) (\_ -> walker287 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker287 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker287 body) Nothing (\inner -> walker287 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 289; recurses to walker288.
+walker289 :: Core.Term -> Maybe Core.Term
+walker289 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker288 fun) (walker288 arg) (\_ -> walker288 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker288 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker288 body) Nothing (\inner -> walker288 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 29; recurses to walker28.
+walker29 :: Core.Term -> Maybe Core.Term
+walker29 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker28 fun) (walker28 arg) (\_ -> walker28 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker28 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker28 body) Nothing (\inner -> walker28 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 290; recurses to walker289.
+walker290 :: Core.Term -> Maybe Core.Term
+walker290 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker289 fun) (walker289 arg) (\_ -> walker289 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker289 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker289 body) Nothing (\inner -> walker289 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 291; recurses to walker290.
+walker291 :: Core.Term -> Maybe Core.Term
+walker291 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker290 fun) (walker290 arg) (\_ -> walker290 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker290 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker290 body) Nothing (\inner -> walker290 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 292; recurses to walker291.
+walker292 :: Core.Term -> Maybe Core.Term
+walker292 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker291 fun) (walker291 arg) (\_ -> walker291 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker291 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker291 body) Nothing (\inner -> walker291 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 293; recurses to walker292.
+walker293 :: Core.Term -> Maybe Core.Term
+walker293 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker292 fun) (walker292 arg) (\_ -> walker292 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker292 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker292 body) Nothing (\inner -> walker292 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 294; recurses to walker293.
+walker294 :: Core.Term -> Maybe Core.Term
+walker294 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker293 fun) (walker293 arg) (\_ -> walker293 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker293 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker293 body) Nothing (\inner -> walker293 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 295; recurses to walker294.
+walker295 :: Core.Term -> Maybe Core.Term
+walker295 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker294 fun) (walker294 arg) (\_ -> walker294 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker294 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker294 body) Nothing (\inner -> walker294 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 296; recurses to walker295.
+walker296 :: Core.Term -> Maybe Core.Term
+walker296 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker295 fun) (walker295 arg) (\_ -> walker295 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker295 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker295 body) Nothing (\inner -> walker295 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 297; recurses to walker296.
+walker297 :: Core.Term -> Maybe Core.Term
+walker297 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker296 fun) (walker296 arg) (\_ -> walker296 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker296 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker296 body) Nothing (\inner -> walker296 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 298; recurses to walker297.
+walker298 :: Core.Term -> Maybe Core.Term
+walker298 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker297 fun) (walker297 arg) (\_ -> walker297 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker297 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker297 body) Nothing (\inner -> walker297 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 299; recurses to walker298.
+walker299 :: Core.Term -> Maybe Core.Term
+walker299 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker298 fun) (walker298 arg) (\_ -> walker298 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker298 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker298 body) Nothing (\inner -> walker298 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 3; recurses to walker2.
+walker3 :: Core.Term -> Maybe Core.Term
+walker3 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker2 fun) (walker2 arg) (\_ -> walker2 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker2 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker2 body) Nothing (\inner -> walker2 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 30; recurses to walker29.
+walker30 :: Core.Term -> Maybe Core.Term
+walker30 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker29 fun) (walker29 arg) (\_ -> walker29 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker29 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker29 body) Nothing (\inner -> walker29 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 300; recurses to walker299.
+walker300 :: Core.Term -> Maybe Core.Term
+walker300 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker299 fun) (walker299 arg) (\_ -> walker299 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker299 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker299 body) Nothing (\inner -> walker299 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 301; recurses to walker300.
+walker301 :: Core.Term -> Maybe Core.Term
+walker301 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker300 fun) (walker300 arg) (\_ -> walker300 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker300 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker300 body) Nothing (\inner -> walker300 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 302; recurses to walker301.
+walker302 :: Core.Term -> Maybe Core.Term
+walker302 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker301 fun) (walker301 arg) (\_ -> walker301 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker301 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker301 body) Nothing (\inner -> walker301 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 303; recurses to walker302.
+walker303 :: Core.Term -> Maybe Core.Term
+walker303 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker302 fun) (walker302 arg) (\_ -> walker302 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker302 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker302 body) Nothing (\inner -> walker302 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 304; recurses to walker303.
+walker304 :: Core.Term -> Maybe Core.Term
+walker304 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker303 fun) (walker303 arg) (\_ -> walker303 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker303 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker303 body) Nothing (\inner -> walker303 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 305; recurses to walker304.
+walker305 :: Core.Term -> Maybe Core.Term
+walker305 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker304 fun) (walker304 arg) (\_ -> walker304 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker304 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker304 body) Nothing (\inner -> walker304 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 306; recurses to walker305.
+walker306 :: Core.Term -> Maybe Core.Term
+walker306 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker305 fun) (walker305 arg) (\_ -> walker305 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker305 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker305 body) Nothing (\inner -> walker305 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 307; recurses to walker306.
+walker307 :: Core.Term -> Maybe Core.Term
+walker307 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker306 fun) (walker306 arg) (\_ -> walker306 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker306 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker306 body) Nothing (\inner -> walker306 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 308; recurses to walker307.
+walker308 :: Core.Term -> Maybe Core.Term
+walker308 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker307 fun) (walker307 arg) (\_ -> walker307 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker307 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker307 body) Nothing (\inner -> walker307 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 309; recurses to walker308.
+walker309 :: Core.Term -> Maybe Core.Term
+walker309 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker308 fun) (walker308 arg) (\_ -> walker308 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker308 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker308 body) Nothing (\inner -> walker308 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 31; recurses to walker30.
+walker31 :: Core.Term -> Maybe Core.Term
+walker31 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker30 fun) (walker30 arg) (\_ -> walker30 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker30 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker30 body) Nothing (\inner -> walker30 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 310; recurses to walker309.
+walker310 :: Core.Term -> Maybe Core.Term
+walker310 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker309 fun) (walker309 arg) (\_ -> walker309 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker309 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker309 body) Nothing (\inner -> walker309 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 311; recurses to walker310.
+walker311 :: Core.Term -> Maybe Core.Term
+walker311 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker310 fun) (walker310 arg) (\_ -> walker310 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker310 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker310 body) Nothing (\inner -> walker310 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 312; recurses to walker311.
+walker312 :: Core.Term -> Maybe Core.Term
+walker312 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker311 fun) (walker311 arg) (\_ -> walker311 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker311 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker311 body) Nothing (\inner -> walker311 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 313; recurses to walker312.
+walker313 :: Core.Term -> Maybe Core.Term
+walker313 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker312 fun) (walker312 arg) (\_ -> walker312 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker312 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker312 body) Nothing (\inner -> walker312 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 314; recurses to walker313.
+walker314 :: Core.Term -> Maybe Core.Term
+walker314 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker313 fun) (walker313 arg) (\_ -> walker313 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker313 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker313 body) Nothing (\inner -> walker313 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 315; recurses to walker314.
+walker315 :: Core.Term -> Maybe Core.Term
+walker315 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker314 fun) (walker314 arg) (\_ -> walker314 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker314 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker314 body) Nothing (\inner -> walker314 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 316; recurses to walker315.
+walker316 :: Core.Term -> Maybe Core.Term
+walker316 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker315 fun) (walker315 arg) (\_ -> walker315 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker315 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker315 body) Nothing (\inner -> walker315 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 317; recurses to walker316.
+walker317 :: Core.Term -> Maybe Core.Term
+walker317 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker316 fun) (walker316 arg) (\_ -> walker316 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker316 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker316 body) Nothing (\inner -> walker316 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 318; recurses to walker317.
+walker318 :: Core.Term -> Maybe Core.Term
+walker318 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker317 fun) (walker317 arg) (\_ -> walker317 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker317 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker317 body) Nothing (\inner -> walker317 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 319; recurses to walker318.
+walker319 :: Core.Term -> Maybe Core.Term
+walker319 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker318 fun) (walker318 arg) (\_ -> walker318 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker318 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker318 body) Nothing (\inner -> walker318 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 32; recurses to walker31.
+walker32 :: Core.Term -> Maybe Core.Term
+walker32 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker31 fun) (walker31 arg) (\_ -> walker31 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker31 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker31 body) Nothing (\inner -> walker31 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 320; recurses to walker319.
+walker320 :: Core.Term -> Maybe Core.Term
+walker320 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker319 fun) (walker319 arg) (\_ -> walker319 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker319 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker319 body) Nothing (\inner -> walker319 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 321; recurses to walker320.
+walker321 :: Core.Term -> Maybe Core.Term
+walker321 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker320 fun) (walker320 arg) (\_ -> walker320 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker320 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker320 body) Nothing (\inner -> walker320 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 322; recurses to walker321.
+walker322 :: Core.Term -> Maybe Core.Term
+walker322 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker321 fun) (walker321 arg) (\_ -> walker321 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker321 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker321 body) Nothing (\inner -> walker321 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 323; recurses to walker322.
+walker323 :: Core.Term -> Maybe Core.Term
+walker323 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker322 fun) (walker322 arg) (\_ -> walker322 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker322 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker322 body) Nothing (\inner -> walker322 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 324; recurses to walker323.
+walker324 :: Core.Term -> Maybe Core.Term
+walker324 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker323 fun) (walker323 arg) (\_ -> walker323 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker323 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker323 body) Nothing (\inner -> walker323 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 325; recurses to walker324.
+walker325 :: Core.Term -> Maybe Core.Term
+walker325 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker324 fun) (walker324 arg) (\_ -> walker324 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker324 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker324 body) Nothing (\inner -> walker324 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 326; recurses to walker325.
+walker326 :: Core.Term -> Maybe Core.Term
+walker326 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker325 fun) (walker325 arg) (\_ -> walker325 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker325 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker325 body) Nothing (\inner -> walker325 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 327; recurses to walker326.
+walker327 :: Core.Term -> Maybe Core.Term
+walker327 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker326 fun) (walker326 arg) (\_ -> walker326 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker326 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker326 body) Nothing (\inner -> walker326 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 328; recurses to walker327.
+walker328 :: Core.Term -> Maybe Core.Term
+walker328 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker327 fun) (walker327 arg) (\_ -> walker327 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker327 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker327 body) Nothing (\inner -> walker327 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 329; recurses to walker328.
+walker329 :: Core.Term -> Maybe Core.Term
+walker329 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker328 fun) (walker328 arg) (\_ -> walker328 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker328 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker328 body) Nothing (\inner -> walker328 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 33; recurses to walker32.
+walker33 :: Core.Term -> Maybe Core.Term
+walker33 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker32 fun) (walker32 arg) (\_ -> walker32 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker32 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker32 body) Nothing (\inner -> walker32 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 330; recurses to walker329.
+walker330 :: Core.Term -> Maybe Core.Term
+walker330 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker329 fun) (walker329 arg) (\_ -> walker329 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker329 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker329 body) Nothing (\inner -> walker329 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 331; recurses to walker330.
+walker331 :: Core.Term -> Maybe Core.Term
+walker331 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker330 fun) (walker330 arg) (\_ -> walker330 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker330 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker330 body) Nothing (\inner -> walker330 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 332; recurses to walker331.
+walker332 :: Core.Term -> Maybe Core.Term
+walker332 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker331 fun) (walker331 arg) (\_ -> walker331 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker331 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker331 body) Nothing (\inner -> walker331 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 333; recurses to walker332.
+walker333 :: Core.Term -> Maybe Core.Term
+walker333 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker332 fun) (walker332 arg) (\_ -> walker332 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker332 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker332 body) Nothing (\inner -> walker332 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 334; recurses to walker333.
+walker334 :: Core.Term -> Maybe Core.Term
+walker334 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker333 fun) (walker333 arg) (\_ -> walker333 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker333 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker333 body) Nothing (\inner -> walker333 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 335; recurses to walker334.
+walker335 :: Core.Term -> Maybe Core.Term
+walker335 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker334 fun) (walker334 arg) (\_ -> walker334 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker334 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker334 body) Nothing (\inner -> walker334 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 336; recurses to walker335.
+walker336 :: Core.Term -> Maybe Core.Term
+walker336 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker335 fun) (walker335 arg) (\_ -> walker335 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker335 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker335 body) Nothing (\inner -> walker335 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 337; recurses to walker336.
+walker337 :: Core.Term -> Maybe Core.Term
+walker337 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker336 fun) (walker336 arg) (\_ -> walker336 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker336 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker336 body) Nothing (\inner -> walker336 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 338; recurses to walker337.
+walker338 :: Core.Term -> Maybe Core.Term
+walker338 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker337 fun) (walker337 arg) (\_ -> walker337 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker337 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker337 body) Nothing (\inner -> walker337 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 339; recurses to walker338.
+walker339 :: Core.Term -> Maybe Core.Term
+walker339 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker338 fun) (walker338 arg) (\_ -> walker338 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker338 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker338 body) Nothing (\inner -> walker338 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 34; recurses to walker33.
+walker34 :: Core.Term -> Maybe Core.Term
+walker34 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker33 fun) (walker33 arg) (\_ -> walker33 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker33 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker33 body) Nothing (\inner -> walker33 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 340; recurses to walker339.
+walker340 :: Core.Term -> Maybe Core.Term
+walker340 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker339 fun) (walker339 arg) (\_ -> walker339 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker339 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker339 body) Nothing (\inner -> walker339 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 341; recurses to walker340.
+walker341 :: Core.Term -> Maybe Core.Term
+walker341 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker340 fun) (walker340 arg) (\_ -> walker340 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker340 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker340 body) Nothing (\inner -> walker340 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 342; recurses to walker341.
+walker342 :: Core.Term -> Maybe Core.Term
+walker342 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker341 fun) (walker341 arg) (\_ -> walker341 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker341 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker341 body) Nothing (\inner -> walker341 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 343; recurses to walker342.
+walker343 :: Core.Term -> Maybe Core.Term
+walker343 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker342 fun) (walker342 arg) (\_ -> walker342 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker342 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker342 body) Nothing (\inner -> walker342 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 344; recurses to walker343.
+walker344 :: Core.Term -> Maybe Core.Term
+walker344 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker343 fun) (walker343 arg) (\_ -> walker343 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker343 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker343 body) Nothing (\inner -> walker343 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 345; recurses to walker344.
+walker345 :: Core.Term -> Maybe Core.Term
+walker345 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker344 fun) (walker344 arg) (\_ -> walker344 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker344 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker344 body) Nothing (\inner -> walker344 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 346; recurses to walker345.
+walker346 :: Core.Term -> Maybe Core.Term
+walker346 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker345 fun) (walker345 arg) (\_ -> walker345 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker345 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker345 body) Nothing (\inner -> walker345 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 347; recurses to walker346.
+walker347 :: Core.Term -> Maybe Core.Term
+walker347 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker346 fun) (walker346 arg) (\_ -> walker346 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker346 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker346 body) Nothing (\inner -> walker346 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 348; recurses to walker347.
+walker348 :: Core.Term -> Maybe Core.Term
+walker348 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker347 fun) (walker347 arg) (\_ -> walker347 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker347 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker347 body) Nothing (\inner -> walker347 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 349; recurses to walker348.
+walker349 :: Core.Term -> Maybe Core.Term
+walker349 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker348 fun) (walker348 arg) (\_ -> walker348 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker348 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker348 body) Nothing (\inner -> walker348 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 35; recurses to walker34.
+walker35 :: Core.Term -> Maybe Core.Term
+walker35 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker34 fun) (walker34 arg) (\_ -> walker34 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker34 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker34 body) Nothing (\inner -> walker34 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 350; recurses to walker349.
+walker350 :: Core.Term -> Maybe Core.Term
+walker350 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker349 fun) (walker349 arg) (\_ -> walker349 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker349 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker349 body) Nothing (\inner -> walker349 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 351; recurses to walker350.
+walker351 :: Core.Term -> Maybe Core.Term
+walker351 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker350 fun) (walker350 arg) (\_ -> walker350 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker350 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker350 body) Nothing (\inner -> walker350 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 352; recurses to walker351.
+walker352 :: Core.Term -> Maybe Core.Term
+walker352 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker351 fun) (walker351 arg) (\_ -> walker351 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker351 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker351 body) Nothing (\inner -> walker351 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 353; recurses to walker352.
+walker353 :: Core.Term -> Maybe Core.Term
+walker353 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker352 fun) (walker352 arg) (\_ -> walker352 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker352 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker352 body) Nothing (\inner -> walker352 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 354; recurses to walker353.
+walker354 :: Core.Term -> Maybe Core.Term
+walker354 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker353 fun) (walker353 arg) (\_ -> walker353 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker353 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker353 body) Nothing (\inner -> walker353 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 355; recurses to walker354.
+walker355 :: Core.Term -> Maybe Core.Term
+walker355 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker354 fun) (walker354 arg) (\_ -> walker354 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker354 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker354 body) Nothing (\inner -> walker354 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 356; recurses to walker355.
+walker356 :: Core.Term -> Maybe Core.Term
+walker356 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker355 fun) (walker355 arg) (\_ -> walker355 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker355 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker355 body) Nothing (\inner -> walker355 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 357; recurses to walker356.
+walker357 :: Core.Term -> Maybe Core.Term
+walker357 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker356 fun) (walker356 arg) (\_ -> walker356 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker356 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker356 body) Nothing (\inner -> walker356 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 358; recurses to walker357.
+walker358 :: Core.Term -> Maybe Core.Term
+walker358 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker357 fun) (walker357 arg) (\_ -> walker357 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker357 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker357 body) Nothing (\inner -> walker357 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 359; recurses to walker358.
+walker359 :: Core.Term -> Maybe Core.Term
+walker359 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker358 fun) (walker358 arg) (\_ -> walker358 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker358 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker358 body) Nothing (\inner -> walker358 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 36; recurses to walker35.
+walker36 :: Core.Term -> Maybe Core.Term
+walker36 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker35 fun) (walker35 arg) (\_ -> walker35 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker35 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker35 body) Nothing (\inner -> walker35 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 360; recurses to walker359.
+walker360 :: Core.Term -> Maybe Core.Term
+walker360 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker359 fun) (walker359 arg) (\_ -> walker359 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker359 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker359 body) Nothing (\inner -> walker359 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 361; recurses to walker360.
+walker361 :: Core.Term -> Maybe Core.Term
+walker361 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker360 fun) (walker360 arg) (\_ -> walker360 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker360 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker360 body) Nothing (\inner -> walker360 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 362; recurses to walker361.
+walker362 :: Core.Term -> Maybe Core.Term
+walker362 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker361 fun) (walker361 arg) (\_ -> walker361 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker361 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker361 body) Nothing (\inner -> walker361 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 363; recurses to walker362.
+walker363 :: Core.Term -> Maybe Core.Term
+walker363 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker362 fun) (walker362 arg) (\_ -> walker362 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker362 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker362 body) Nothing (\inner -> walker362 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 364; recurses to walker363.
+walker364 :: Core.Term -> Maybe Core.Term
+walker364 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker363 fun) (walker363 arg) (\_ -> walker363 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker363 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker363 body) Nothing (\inner -> walker363 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 365; recurses to walker364.
+walker365 :: Core.Term -> Maybe Core.Term
+walker365 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker364 fun) (walker364 arg) (\_ -> walker364 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker364 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker364 body) Nothing (\inner -> walker364 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 366; recurses to walker365.
+walker366 :: Core.Term -> Maybe Core.Term
+walker366 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker365 fun) (walker365 arg) (\_ -> walker365 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker365 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker365 body) Nothing (\inner -> walker365 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 367; recurses to walker366.
+walker367 :: Core.Term -> Maybe Core.Term
+walker367 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker366 fun) (walker366 arg) (\_ -> walker366 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker366 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker366 body) Nothing (\inner -> walker366 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 368; recurses to walker367.
+walker368 :: Core.Term -> Maybe Core.Term
+walker368 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker367 fun) (walker367 arg) (\_ -> walker367 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker367 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker367 body) Nothing (\inner -> walker367 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 369; recurses to walker368.
+walker369 :: Core.Term -> Maybe Core.Term
+walker369 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker368 fun) (walker368 arg) (\_ -> walker368 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker368 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker368 body) Nothing (\inner -> walker368 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 37; recurses to walker36.
+walker37 :: Core.Term -> Maybe Core.Term
+walker37 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker36 fun) (walker36 arg) (\_ -> walker36 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker36 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker36 body) Nothing (\inner -> walker36 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 370; recurses to walker369.
+walker370 :: Core.Term -> Maybe Core.Term
+walker370 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker369 fun) (walker369 arg) (\_ -> walker369 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker369 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker369 body) Nothing (\inner -> walker369 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 371; recurses to walker370.
+walker371 :: Core.Term -> Maybe Core.Term
+walker371 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker370 fun) (walker370 arg) (\_ -> walker370 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker370 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker370 body) Nothing (\inner -> walker370 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 372; recurses to walker371.
+walker372 :: Core.Term -> Maybe Core.Term
+walker372 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker371 fun) (walker371 arg) (\_ -> walker371 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker371 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker371 body) Nothing (\inner -> walker371 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 373; recurses to walker372.
+walker373 :: Core.Term -> Maybe Core.Term
+walker373 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker372 fun) (walker372 arg) (\_ -> walker372 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker372 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker372 body) Nothing (\inner -> walker372 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 374; recurses to walker373.
+walker374 :: Core.Term -> Maybe Core.Term
+walker374 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker373 fun) (walker373 arg) (\_ -> walker373 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker373 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker373 body) Nothing (\inner -> walker373 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 375; recurses to walker374.
+walker375 :: Core.Term -> Maybe Core.Term
+walker375 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker374 fun) (walker374 arg) (\_ -> walker374 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker374 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker374 body) Nothing (\inner -> walker374 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 376; recurses to walker375.
+walker376 :: Core.Term -> Maybe Core.Term
+walker376 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker375 fun) (walker375 arg) (\_ -> walker375 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker375 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker375 body) Nothing (\inner -> walker375 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 377; recurses to walker376.
+walker377 :: Core.Term -> Maybe Core.Term
+walker377 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker376 fun) (walker376 arg) (\_ -> walker376 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker376 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker376 body) Nothing (\inner -> walker376 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 378; recurses to walker377.
+walker378 :: Core.Term -> Maybe Core.Term
+walker378 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker377 fun) (walker377 arg) (\_ -> walker377 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker377 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker377 body) Nothing (\inner -> walker377 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 379; recurses to walker378.
+walker379 :: Core.Term -> Maybe Core.Term
+walker379 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker378 fun) (walker378 arg) (\_ -> walker378 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker378 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker378 body) Nothing (\inner -> walker378 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 38; recurses to walker37.
+walker38 :: Core.Term -> Maybe Core.Term
+walker38 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker37 fun) (walker37 arg) (\_ -> walker37 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker37 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker37 body) Nothing (\inner -> walker37 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 380; recurses to walker379.
+walker380 :: Core.Term -> Maybe Core.Term
+walker380 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker379 fun) (walker379 arg) (\_ -> walker379 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker379 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker379 body) Nothing (\inner -> walker379 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 381; recurses to walker380.
+walker381 :: Core.Term -> Maybe Core.Term
+walker381 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker380 fun) (walker380 arg) (\_ -> walker380 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker380 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker380 body) Nothing (\inner -> walker380 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 382; recurses to walker381.
+walker382 :: Core.Term -> Maybe Core.Term
+walker382 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker381 fun) (walker381 arg) (\_ -> walker381 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker381 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker381 body) Nothing (\inner -> walker381 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 383; recurses to walker382.
+walker383 :: Core.Term -> Maybe Core.Term
+walker383 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker382 fun) (walker382 arg) (\_ -> walker382 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker382 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker382 body) Nothing (\inner -> walker382 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 384; recurses to walker383.
+walker384 :: Core.Term -> Maybe Core.Term
+walker384 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker383 fun) (walker383 arg) (\_ -> walker383 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker383 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker383 body) Nothing (\inner -> walker383 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 385; recurses to walker384.
+walker385 :: Core.Term -> Maybe Core.Term
+walker385 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker384 fun) (walker384 arg) (\_ -> walker384 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker384 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker384 body) Nothing (\inner -> walker384 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 386; recurses to walker385.
+walker386 :: Core.Term -> Maybe Core.Term
+walker386 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker385 fun) (walker385 arg) (\_ -> walker385 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker385 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker385 body) Nothing (\inner -> walker385 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 387; recurses to walker386.
+walker387 :: Core.Term -> Maybe Core.Term
+walker387 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker386 fun) (walker386 arg) (\_ -> walker386 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker386 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker386 body) Nothing (\inner -> walker386 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 388; recurses to walker387.
+walker388 :: Core.Term -> Maybe Core.Term
+walker388 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker387 fun) (walker387 arg) (\_ -> walker387 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker387 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker387 body) Nothing (\inner -> walker387 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 389; recurses to walker388.
+walker389 :: Core.Term -> Maybe Core.Term
+walker389 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker388 fun) (walker388 arg) (\_ -> walker388 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker388 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker388 body) Nothing (\inner -> walker388 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 39; recurses to walker38.
+walker39 :: Core.Term -> Maybe Core.Term
+walker39 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker38 fun) (walker38 arg) (\_ -> walker38 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker38 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker38 body) Nothing (\inner -> walker38 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 390; recurses to walker389.
+walker390 :: Core.Term -> Maybe Core.Term
+walker390 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker389 fun) (walker389 arg) (\_ -> walker389 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker389 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker389 body) Nothing (\inner -> walker389 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 391; recurses to walker390.
+walker391 :: Core.Term -> Maybe Core.Term
+walker391 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker390 fun) (walker390 arg) (\_ -> walker390 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker390 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker390 body) Nothing (\inner -> walker390 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 392; recurses to walker391.
+walker392 :: Core.Term -> Maybe Core.Term
+walker392 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker391 fun) (walker391 arg) (\_ -> walker391 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker391 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker391 body) Nothing (\inner -> walker391 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 393; recurses to walker392.
+walker393 :: Core.Term -> Maybe Core.Term
+walker393 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker392 fun) (walker392 arg) (\_ -> walker392 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker392 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker392 body) Nothing (\inner -> walker392 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 394; recurses to walker393.
+walker394 :: Core.Term -> Maybe Core.Term
+walker394 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker393 fun) (walker393 arg) (\_ -> walker393 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker393 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker393 body) Nothing (\inner -> walker393 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 395; recurses to walker394.
+walker395 :: Core.Term -> Maybe Core.Term
+walker395 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker394 fun) (walker394 arg) (\_ -> walker394 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker394 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker394 body) Nothing (\inner -> walker394 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 396; recurses to walker395.
+walker396 :: Core.Term -> Maybe Core.Term
+walker396 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker395 fun) (walker395 arg) (\_ -> walker395 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker395 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker395 body) Nothing (\inner -> walker395 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 397; recurses to walker396.
+walker397 :: Core.Term -> Maybe Core.Term
+walker397 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker396 fun) (walker396 arg) (\_ -> walker396 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker396 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker396 body) Nothing (\inner -> walker396 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 398; recurses to walker397.
+walker398 :: Core.Term -> Maybe Core.Term
+walker398 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker397 fun) (walker397 arg) (\_ -> walker397 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker397 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker397 body) Nothing (\inner -> walker397 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 399; recurses to walker398.
+walker399 :: Core.Term -> Maybe Core.Term
+walker399 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker398 fun) (walker398 arg) (\_ -> walker398 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker398 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker398 body) Nothing (\inner -> walker398 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 4; recurses to walker3.
+walker4 :: Core.Term -> Maybe Core.Term
+walker4 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker3 fun) (walker3 arg) (\_ -> walker3 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker3 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker3 body) Nothing (\inner -> walker3 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 40; recurses to walker39.
+walker40 :: Core.Term -> Maybe Core.Term
+walker40 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker39 fun) (walker39 arg) (\_ -> walker39 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker39 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker39 body) Nothing (\inner -> walker39 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 400; recurses to walker399.
+walker400 :: Core.Term -> Maybe Core.Term
+walker400 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker399 fun) (walker399 arg) (\_ -> walker399 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker399 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker399 body) Nothing (\inner -> walker399 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 401; recurses to walker400.
+walker401 :: Core.Term -> Maybe Core.Term
+walker401 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker400 fun) (walker400 arg) (\_ -> walker400 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker400 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker400 body) Nothing (\inner -> walker400 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 402; recurses to walker401.
+walker402 :: Core.Term -> Maybe Core.Term
+walker402 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker401 fun) (walker401 arg) (\_ -> walker401 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker401 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker401 body) Nothing (\inner -> walker401 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 403; recurses to walker402.
+walker403 :: Core.Term -> Maybe Core.Term
+walker403 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker402 fun) (walker402 arg) (\_ -> walker402 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker402 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker402 body) Nothing (\inner -> walker402 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 404; recurses to walker403.
+walker404 :: Core.Term -> Maybe Core.Term
+walker404 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker403 fun) (walker403 arg) (\_ -> walker403 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker403 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker403 body) Nothing (\inner -> walker403 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 405; recurses to walker404.
+walker405 :: Core.Term -> Maybe Core.Term
+walker405 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker404 fun) (walker404 arg) (\_ -> walker404 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker404 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker404 body) Nothing (\inner -> walker404 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 406; recurses to walker405.
+walker406 :: Core.Term -> Maybe Core.Term
+walker406 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker405 fun) (walker405 arg) (\_ -> walker405 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker405 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker405 body) Nothing (\inner -> walker405 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 407; recurses to walker406.
+walker407 :: Core.Term -> Maybe Core.Term
+walker407 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker406 fun) (walker406 arg) (\_ -> walker406 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker406 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker406 body) Nothing (\inner -> walker406 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 408; recurses to walker407.
+walker408 :: Core.Term -> Maybe Core.Term
+walker408 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker407 fun) (walker407 arg) (\_ -> walker407 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker407 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker407 body) Nothing (\inner -> walker407 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 409; recurses to walker408.
+walker409 :: Core.Term -> Maybe Core.Term
+walker409 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker408 fun) (walker408 arg) (\_ -> walker408 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker408 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker408 body) Nothing (\inner -> walker408 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 41; recurses to walker40.
+walker41 :: Core.Term -> Maybe Core.Term
+walker41 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker40 fun) (walker40 arg) (\_ -> walker40 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker40 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker40 body) Nothing (\inner -> walker40 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 410; recurses to walker409.
+walker410 :: Core.Term -> Maybe Core.Term
+walker410 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker409 fun) (walker409 arg) (\_ -> walker409 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker409 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker409 body) Nothing (\inner -> walker409 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 411; recurses to walker410.
+walker411 :: Core.Term -> Maybe Core.Term
+walker411 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker410 fun) (walker410 arg) (\_ -> walker410 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker410 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker410 body) Nothing (\inner -> walker410 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 412; recurses to walker411.
+walker412 :: Core.Term -> Maybe Core.Term
+walker412 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker411 fun) (walker411 arg) (\_ -> walker411 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker411 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker411 body) Nothing (\inner -> walker411 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 413; recurses to walker412.
+walker413 :: Core.Term -> Maybe Core.Term
+walker413 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker412 fun) (walker412 arg) (\_ -> walker412 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker412 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker412 body) Nothing (\inner -> walker412 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 414; recurses to walker413.
+walker414 :: Core.Term -> Maybe Core.Term
+walker414 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker413 fun) (walker413 arg) (\_ -> walker413 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker413 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker413 body) Nothing (\inner -> walker413 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 415; recurses to walker414.
+walker415 :: Core.Term -> Maybe Core.Term
+walker415 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker414 fun) (walker414 arg) (\_ -> walker414 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker414 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker414 body) Nothing (\inner -> walker414 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 416; recurses to walker415.
+walker416 :: Core.Term -> Maybe Core.Term
+walker416 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker415 fun) (walker415 arg) (\_ -> walker415 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker415 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker415 body) Nothing (\inner -> walker415 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 417; recurses to walker416.
+walker417 :: Core.Term -> Maybe Core.Term
+walker417 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker416 fun) (walker416 arg) (\_ -> walker416 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker416 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker416 body) Nothing (\inner -> walker416 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 418; recurses to walker417.
+walker418 :: Core.Term -> Maybe Core.Term
+walker418 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker417 fun) (walker417 arg) (\_ -> walker417 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker417 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker417 body) Nothing (\inner -> walker417 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 419; recurses to walker418.
+walker419 :: Core.Term -> Maybe Core.Term
+walker419 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker418 fun) (walker418 arg) (\_ -> walker418 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker418 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker418 body) Nothing (\inner -> walker418 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 42; recurses to walker41.
+walker42 :: Core.Term -> Maybe Core.Term
+walker42 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker41 fun) (walker41 arg) (\_ -> walker41 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker41 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker41 body) Nothing (\inner -> walker41 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 420; recurses to walker419.
+walker420 :: Core.Term -> Maybe Core.Term
+walker420 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker419 fun) (walker419 arg) (\_ -> walker419 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker419 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker419 body) Nothing (\inner -> walker419 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 421; recurses to walker420.
+walker421 :: Core.Term -> Maybe Core.Term
+walker421 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker420 fun) (walker420 arg) (\_ -> walker420 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker420 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker420 body) Nothing (\inner -> walker420 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 422; recurses to walker421.
+walker422 :: Core.Term -> Maybe Core.Term
+walker422 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker421 fun) (walker421 arg) (\_ -> walker421 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker421 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker421 body) Nothing (\inner -> walker421 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 423; recurses to walker422.
+walker423 :: Core.Term -> Maybe Core.Term
+walker423 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker422 fun) (walker422 arg) (\_ -> walker422 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker422 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker422 body) Nothing (\inner -> walker422 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 424; recurses to walker423.
+walker424 :: Core.Term -> Maybe Core.Term
+walker424 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker423 fun) (walker423 arg) (\_ -> walker423 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker423 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker423 body) Nothing (\inner -> walker423 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 425; recurses to walker424.
+walker425 :: Core.Term -> Maybe Core.Term
+walker425 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker424 fun) (walker424 arg) (\_ -> walker424 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker424 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker424 body) Nothing (\inner -> walker424 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 426; recurses to walker425.
+walker426 :: Core.Term -> Maybe Core.Term
+walker426 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker425 fun) (walker425 arg) (\_ -> walker425 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker425 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker425 body) Nothing (\inner -> walker425 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 427; recurses to walker426.
+walker427 :: Core.Term -> Maybe Core.Term
+walker427 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker426 fun) (walker426 arg) (\_ -> walker426 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker426 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker426 body) Nothing (\inner -> walker426 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 428; recurses to walker427.
+walker428 :: Core.Term -> Maybe Core.Term
+walker428 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker427 fun) (walker427 arg) (\_ -> walker427 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker427 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker427 body) Nothing (\inner -> walker427 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 429; recurses to walker428.
+walker429 :: Core.Term -> Maybe Core.Term
+walker429 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker428 fun) (walker428 arg) (\_ -> walker428 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker428 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker428 body) Nothing (\inner -> walker428 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 43; recurses to walker42.
+walker43 :: Core.Term -> Maybe Core.Term
+walker43 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker42 fun) (walker42 arg) (\_ -> walker42 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker42 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker42 body) Nothing (\inner -> walker42 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 430; recurses to walker429.
+walker430 :: Core.Term -> Maybe Core.Term
+walker430 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker429 fun) (walker429 arg) (\_ -> walker429 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker429 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker429 body) Nothing (\inner -> walker429 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 431; recurses to walker430.
+walker431 :: Core.Term -> Maybe Core.Term
+walker431 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker430 fun) (walker430 arg) (\_ -> walker430 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker430 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker430 body) Nothing (\inner -> walker430 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 432; recurses to walker431.
+walker432 :: Core.Term -> Maybe Core.Term
+walker432 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker431 fun) (walker431 arg) (\_ -> walker431 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker431 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker431 body) Nothing (\inner -> walker431 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 433; recurses to walker432.
+walker433 :: Core.Term -> Maybe Core.Term
+walker433 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker432 fun) (walker432 arg) (\_ -> walker432 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker432 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker432 body) Nothing (\inner -> walker432 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 434; recurses to walker433.
+walker434 :: Core.Term -> Maybe Core.Term
+walker434 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker433 fun) (walker433 arg) (\_ -> walker433 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker433 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker433 body) Nothing (\inner -> walker433 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 435; recurses to walker434.
+walker435 :: Core.Term -> Maybe Core.Term
+walker435 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker434 fun) (walker434 arg) (\_ -> walker434 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker434 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker434 body) Nothing (\inner -> walker434 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 436; recurses to walker435.
+walker436 :: Core.Term -> Maybe Core.Term
+walker436 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker435 fun) (walker435 arg) (\_ -> walker435 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker435 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker435 body) Nothing (\inner -> walker435 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 437; recurses to walker436.
+walker437 :: Core.Term -> Maybe Core.Term
+walker437 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker436 fun) (walker436 arg) (\_ -> walker436 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker436 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker436 body) Nothing (\inner -> walker436 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 438; recurses to walker437.
+walker438 :: Core.Term -> Maybe Core.Term
+walker438 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker437 fun) (walker437 arg) (\_ -> walker437 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker437 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker437 body) Nothing (\inner -> walker437 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 439; recurses to walker438.
+walker439 :: Core.Term -> Maybe Core.Term
+walker439 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker438 fun) (walker438 arg) (\_ -> walker438 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker438 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker438 body) Nothing (\inner -> walker438 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 44; recurses to walker43.
+walker44 :: Core.Term -> Maybe Core.Term
+walker44 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker43 fun) (walker43 arg) (\_ -> walker43 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker43 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker43 body) Nothing (\inner -> walker43 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 440; recurses to walker439.
+walker440 :: Core.Term -> Maybe Core.Term
+walker440 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker439 fun) (walker439 arg) (\_ -> walker439 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker439 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker439 body) Nothing (\inner -> walker439 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 441; recurses to walker440.
+walker441 :: Core.Term -> Maybe Core.Term
+walker441 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker440 fun) (walker440 arg) (\_ -> walker440 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker440 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker440 body) Nothing (\inner -> walker440 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 442; recurses to walker441.
+walker442 :: Core.Term -> Maybe Core.Term
+walker442 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker441 fun) (walker441 arg) (\_ -> walker441 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker441 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker441 body) Nothing (\inner -> walker441 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 443; recurses to walker442.
+walker443 :: Core.Term -> Maybe Core.Term
+walker443 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker442 fun) (walker442 arg) (\_ -> walker442 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker442 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker442 body) Nothing (\inner -> walker442 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 444; recurses to walker443.
+walker444 :: Core.Term -> Maybe Core.Term
+walker444 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker443 fun) (walker443 arg) (\_ -> walker443 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker443 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker443 body) Nothing (\inner -> walker443 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 445; recurses to walker444.
+walker445 :: Core.Term -> Maybe Core.Term
+walker445 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker444 fun) (walker444 arg) (\_ -> walker444 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker444 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker444 body) Nothing (\inner -> walker444 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 446; recurses to walker445.
+walker446 :: Core.Term -> Maybe Core.Term
+walker446 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker445 fun) (walker445 arg) (\_ -> walker445 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker445 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker445 body) Nothing (\inner -> walker445 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 447; recurses to walker446.
+walker447 :: Core.Term -> Maybe Core.Term
+walker447 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker446 fun) (walker446 arg) (\_ -> walker446 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker446 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker446 body) Nothing (\inner -> walker446 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 448; recurses to walker447.
+walker448 :: Core.Term -> Maybe Core.Term
+walker448 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker447 fun) (walker447 arg) (\_ -> walker447 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker447 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker447 body) Nothing (\inner -> walker447 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 449; recurses to walker448.
+walker449 :: Core.Term -> Maybe Core.Term
+walker449 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker448 fun) (walker448 arg) (\_ -> walker448 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker448 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker448 body) Nothing (\inner -> walker448 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 45; recurses to walker44.
+walker45 :: Core.Term -> Maybe Core.Term
+walker45 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker44 fun) (walker44 arg) (\_ -> walker44 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker44 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker44 body) Nothing (\inner -> walker44 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 450; recurses to walker449.
+walker450 :: Core.Term -> Maybe Core.Term
+walker450 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker449 fun) (walker449 arg) (\_ -> walker449 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker449 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker449 body) Nothing (\inner -> walker449 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 451; recurses to walker450.
+walker451 :: Core.Term -> Maybe Core.Term
+walker451 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker450 fun) (walker450 arg) (\_ -> walker450 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker450 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker450 body) Nothing (\inner -> walker450 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 452; recurses to walker451.
+walker452 :: Core.Term -> Maybe Core.Term
+walker452 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker451 fun) (walker451 arg) (\_ -> walker451 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker451 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker451 body) Nothing (\inner -> walker451 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 453; recurses to walker452.
+walker453 :: Core.Term -> Maybe Core.Term
+walker453 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker452 fun) (walker452 arg) (\_ -> walker452 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker452 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker452 body) Nothing (\inner -> walker452 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 454; recurses to walker453.
+walker454 :: Core.Term -> Maybe Core.Term
+walker454 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker453 fun) (walker453 arg) (\_ -> walker453 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker453 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker453 body) Nothing (\inner -> walker453 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 455; recurses to walker454.
+walker455 :: Core.Term -> Maybe Core.Term
+walker455 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker454 fun) (walker454 arg) (\_ -> walker454 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker454 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker454 body) Nothing (\inner -> walker454 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 456; recurses to walker455.
+walker456 :: Core.Term -> Maybe Core.Term
+walker456 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker455 fun) (walker455 arg) (\_ -> walker455 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker455 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker455 body) Nothing (\inner -> walker455 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 457; recurses to walker456.
+walker457 :: Core.Term -> Maybe Core.Term
+walker457 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker456 fun) (walker456 arg) (\_ -> walker456 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker456 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker456 body) Nothing (\inner -> walker456 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 458; recurses to walker457.
+walker458 :: Core.Term -> Maybe Core.Term
+walker458 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker457 fun) (walker457 arg) (\_ -> walker457 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker457 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker457 body) Nothing (\inner -> walker457 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 459; recurses to walker458.
+walker459 :: Core.Term -> Maybe Core.Term
+walker459 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker458 fun) (walker458 arg) (\_ -> walker458 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker458 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker458 body) Nothing (\inner -> walker458 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 46; recurses to walker45.
+walker46 :: Core.Term -> Maybe Core.Term
+walker46 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker45 fun) (walker45 arg) (\_ -> walker45 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker45 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker45 body) Nothing (\inner -> walker45 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 460; recurses to walker459.
+walker460 :: Core.Term -> Maybe Core.Term
+walker460 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker459 fun) (walker459 arg) (\_ -> walker459 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker459 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker459 body) Nothing (\inner -> walker459 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 461; recurses to walker460.
+walker461 :: Core.Term -> Maybe Core.Term
+walker461 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker460 fun) (walker460 arg) (\_ -> walker460 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker460 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker460 body) Nothing (\inner -> walker460 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 462; recurses to walker461.
+walker462 :: Core.Term -> Maybe Core.Term
+walker462 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker461 fun) (walker461 arg) (\_ -> walker461 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker461 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker461 body) Nothing (\inner -> walker461 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 463; recurses to walker462.
+walker463 :: Core.Term -> Maybe Core.Term
+walker463 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker462 fun) (walker462 arg) (\_ -> walker462 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker462 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker462 body) Nothing (\inner -> walker462 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 464; recurses to walker463.
+walker464 :: Core.Term -> Maybe Core.Term
+walker464 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker463 fun) (walker463 arg) (\_ -> walker463 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker463 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker463 body) Nothing (\inner -> walker463 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 465; recurses to walker464.
+walker465 :: Core.Term -> Maybe Core.Term
+walker465 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker464 fun) (walker464 arg) (\_ -> walker464 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker464 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker464 body) Nothing (\inner -> walker464 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 466; recurses to walker465.
+walker466 :: Core.Term -> Maybe Core.Term
+walker466 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker465 fun) (walker465 arg) (\_ -> walker465 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker465 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker465 body) Nothing (\inner -> walker465 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 467; recurses to walker466.
+walker467 :: Core.Term -> Maybe Core.Term
+walker467 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker466 fun) (walker466 arg) (\_ -> walker466 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker466 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker466 body) Nothing (\inner -> walker466 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 468; recurses to walker467.
+walker468 :: Core.Term -> Maybe Core.Term
+walker468 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker467 fun) (walker467 arg) (\_ -> walker467 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker467 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker467 body) Nothing (\inner -> walker467 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 469; recurses to walker468.
+walker469 :: Core.Term -> Maybe Core.Term
+walker469 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker468 fun) (walker468 arg) (\_ -> walker468 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker468 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker468 body) Nothing (\inner -> walker468 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 47; recurses to walker46.
+walker47 :: Core.Term -> Maybe Core.Term
+walker47 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker46 fun) (walker46 arg) (\_ -> walker46 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker46 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker46 body) Nothing (\inner -> walker46 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 470; recurses to walker469.
+walker470 :: Core.Term -> Maybe Core.Term
+walker470 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker469 fun) (walker469 arg) (\_ -> walker469 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker469 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker469 body) Nothing (\inner -> walker469 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 471; recurses to walker470.
+walker471 :: Core.Term -> Maybe Core.Term
+walker471 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker470 fun) (walker470 arg) (\_ -> walker470 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker470 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker470 body) Nothing (\inner -> walker470 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 472; recurses to walker471.
+walker472 :: Core.Term -> Maybe Core.Term
+walker472 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker471 fun) (walker471 arg) (\_ -> walker471 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker471 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker471 body) Nothing (\inner -> walker471 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 473; recurses to walker472.
+walker473 :: Core.Term -> Maybe Core.Term
+walker473 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker472 fun) (walker472 arg) (\_ -> walker472 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker472 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker472 body) Nothing (\inner -> walker472 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 474; recurses to walker473.
+walker474 :: Core.Term -> Maybe Core.Term
+walker474 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker473 fun) (walker473 arg) (\_ -> walker473 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker473 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker473 body) Nothing (\inner -> walker473 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 475; recurses to walker474.
+walker475 :: Core.Term -> Maybe Core.Term
+walker475 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker474 fun) (walker474 arg) (\_ -> walker474 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker474 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker474 body) Nothing (\inner -> walker474 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 476; recurses to walker475.
+walker476 :: Core.Term -> Maybe Core.Term
+walker476 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker475 fun) (walker475 arg) (\_ -> walker475 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker475 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker475 body) Nothing (\inner -> walker475 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 477; recurses to walker476.
+walker477 :: Core.Term -> Maybe Core.Term
+walker477 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker476 fun) (walker476 arg) (\_ -> walker476 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker476 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker476 body) Nothing (\inner -> walker476 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 478; recurses to walker477.
+walker478 :: Core.Term -> Maybe Core.Term
+walker478 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker477 fun) (walker477 arg) (\_ -> walker477 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker477 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker477 body) Nothing (\inner -> walker477 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 479; recurses to walker478.
+walker479 :: Core.Term -> Maybe Core.Term
+walker479 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker478 fun) (walker478 arg) (\_ -> walker478 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker478 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker478 body) Nothing (\inner -> walker478 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 48; recurses to walker47.
+walker48 :: Core.Term -> Maybe Core.Term
+walker48 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker47 fun) (walker47 arg) (\_ -> walker47 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker47 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker47 body) Nothing (\inner -> walker47 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 480; recurses to walker479.
+walker480 :: Core.Term -> Maybe Core.Term
+walker480 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker479 fun) (walker479 arg) (\_ -> walker479 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker479 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker479 body) Nothing (\inner -> walker479 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 481; recurses to walker480.
+walker481 :: Core.Term -> Maybe Core.Term
+walker481 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker480 fun) (walker480 arg) (\_ -> walker480 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker480 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker480 body) Nothing (\inner -> walker480 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 482; recurses to walker481.
+walker482 :: Core.Term -> Maybe Core.Term
+walker482 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker481 fun) (walker481 arg) (\_ -> walker481 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker481 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker481 body) Nothing (\inner -> walker481 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 483; recurses to walker482.
+walker483 :: Core.Term -> Maybe Core.Term
+walker483 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker482 fun) (walker482 arg) (\_ -> walker482 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker482 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker482 body) Nothing (\inner -> walker482 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 484; recurses to walker483.
+walker484 :: Core.Term -> Maybe Core.Term
+walker484 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker483 fun) (walker483 arg) (\_ -> walker483 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker483 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker483 body) Nothing (\inner -> walker483 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 485; recurses to walker484.
+walker485 :: Core.Term -> Maybe Core.Term
+walker485 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker484 fun) (walker484 arg) (\_ -> walker484 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker484 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker484 body) Nothing (\inner -> walker484 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 486; recurses to walker485.
+walker486 :: Core.Term -> Maybe Core.Term
+walker486 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker485 fun) (walker485 arg) (\_ -> walker485 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker485 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker485 body) Nothing (\inner -> walker485 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 487; recurses to walker486.
+walker487 :: Core.Term -> Maybe Core.Term
+walker487 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker486 fun) (walker486 arg) (\_ -> walker486 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker486 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker486 body) Nothing (\inner -> walker486 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 488; recurses to walker487.
+walker488 :: Core.Term -> Maybe Core.Term
+walker488 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker487 fun) (walker487 arg) (\_ -> walker487 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker487 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker487 body) Nothing (\inner -> walker487 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 489; recurses to walker488.
+walker489 :: Core.Term -> Maybe Core.Term
+walker489 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker488 fun) (walker488 arg) (\_ -> walker488 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker488 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker488 body) Nothing (\inner -> walker488 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 49; recurses to walker48.
+walker49 :: Core.Term -> Maybe Core.Term
+walker49 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker48 fun) (walker48 arg) (\_ -> walker48 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker48 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker48 body) Nothing (\inner -> walker48 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 490; recurses to walker489.
+walker490 :: Core.Term -> Maybe Core.Term
+walker490 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker489 fun) (walker489 arg) (\_ -> walker489 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker489 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker489 body) Nothing (\inner -> walker489 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 491; recurses to walker490.
+walker491 :: Core.Term -> Maybe Core.Term
+walker491 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker490 fun) (walker490 arg) (\_ -> walker490 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker490 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker490 body) Nothing (\inner -> walker490 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 492; recurses to walker491.
+walker492 :: Core.Term -> Maybe Core.Term
+walker492 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker491 fun) (walker491 arg) (\_ -> walker491 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker491 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker491 body) Nothing (\inner -> walker491 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 493; recurses to walker492.
+walker493 :: Core.Term -> Maybe Core.Term
+walker493 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker492 fun) (walker492 arg) (\_ -> walker492 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker492 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker492 body) Nothing (\inner -> walker492 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 494; recurses to walker493.
+walker494 :: Core.Term -> Maybe Core.Term
+walker494 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker493 fun) (walker493 arg) (\_ -> walker493 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker493 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker493 body) Nothing (\inner -> walker493 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 495; recurses to walker494.
+walker495 :: Core.Term -> Maybe Core.Term
+walker495 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker494 fun) (walker494 arg) (\_ -> walker494 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker494 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker494 body) Nothing (\inner -> walker494 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 496; recurses to walker495.
+walker496 :: Core.Term -> Maybe Core.Term
+walker496 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker495 fun) (walker495 arg) (\_ -> walker495 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker495 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker495 body) Nothing (\inner -> walker495 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 497; recurses to walker496.
+walker497 :: Core.Term -> Maybe Core.Term
+walker497 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker496 fun) (walker496 arg) (\_ -> walker496 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker496 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker496 body) Nothing (\inner -> walker496 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 498; recurses to walker497.
+walker498 :: Core.Term -> Maybe Core.Term
+walker498 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker497 fun) (walker497 arg) (\_ -> walker497 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker497 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker497 body) Nothing (\inner -> walker497 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 499; recurses to walker498.
+walker499 :: Core.Term -> Maybe Core.Term
+walker499 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker498 fun) (walker498 arg) (\_ -> walker498 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker498 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker498 body) Nothing (\inner -> walker498 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 5; recurses to walker4.
+walker5 :: Core.Term -> Maybe Core.Term
+walker5 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker4 fun) (walker4 arg) (\_ -> walker4 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker4 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker4 body) Nothing (\inner -> walker4 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 50; recurses to walker49.
+walker50 :: Core.Term -> Maybe Core.Term
+walker50 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker49 fun) (walker49 arg) (\_ -> walker49 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker49 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker49 body) Nothing (\inner -> walker49 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 500; recurses to walker499.
+walker500 :: Core.Term -> Maybe Core.Term
+walker500 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker499 fun) (walker499 arg) (\_ -> walker499 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker499 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker499 body) Nothing (\inner -> walker499 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 501; recurses to walker500.
+walker501 :: Core.Term -> Maybe Core.Term
+walker501 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker500 fun) (walker500 arg) (\_ -> walker500 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker500 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker500 body) Nothing (\inner -> walker500 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 502; recurses to walker501.
+walker502 :: Core.Term -> Maybe Core.Term
+walker502 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker501 fun) (walker501 arg) (\_ -> walker501 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker501 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker501 body) Nothing (\inner -> walker501 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 503; recurses to walker502.
+walker503 :: Core.Term -> Maybe Core.Term
+walker503 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker502 fun) (walker502 arg) (\_ -> walker502 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker502 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker502 body) Nothing (\inner -> walker502 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 504; recurses to walker503.
+walker504 :: Core.Term -> Maybe Core.Term
+walker504 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker503 fun) (walker503 arg) (\_ -> walker503 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker503 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker503 body) Nothing (\inner -> walker503 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 505; recurses to walker504.
+walker505 :: Core.Term -> Maybe Core.Term
+walker505 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker504 fun) (walker504 arg) (\_ -> walker504 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker504 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker504 body) Nothing (\inner -> walker504 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 506; recurses to walker505.
+walker506 :: Core.Term -> Maybe Core.Term
+walker506 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker505 fun) (walker505 arg) (\_ -> walker505 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker505 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker505 body) Nothing (\inner -> walker505 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 507; recurses to walker506.
+walker507 :: Core.Term -> Maybe Core.Term
+walker507 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker506 fun) (walker506 arg) (\_ -> walker506 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker506 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker506 body) Nothing (\inner -> walker506 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 508; recurses to walker507.
+walker508 :: Core.Term -> Maybe Core.Term
+walker508 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker507 fun) (walker507 arg) (\_ -> walker507 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker507 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker507 body) Nothing (\inner -> walker507 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 509; recurses to walker508.
+walker509 :: Core.Term -> Maybe Core.Term
+walker509 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker508 fun) (walker508 arg) (\_ -> walker508 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker508 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker508 body) Nothing (\inner -> walker508 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 51; recurses to walker50.
+walker51 :: Core.Term -> Maybe Core.Term
+walker51 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker50 fun) (walker50 arg) (\_ -> walker50 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker50 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker50 body) Nothing (\inner -> walker50 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 510; recurses to walker509.
+walker510 :: Core.Term -> Maybe Core.Term
+walker510 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker509 fun) (walker509 arg) (\_ -> walker509 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker509 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker509 body) Nothing (\inner -> walker509 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 511; recurses to walker510.
+walker511 :: Core.Term -> Maybe Core.Term
+walker511 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker510 fun) (walker510 arg) (\_ -> walker510 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker510 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker510 body) Nothing (\inner -> walker510 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 512; recurses to walker511.
+walker512 :: Core.Term -> Maybe Core.Term
+walker512 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker511 fun) (walker511 arg) (\_ -> walker511 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker511 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker511 body) Nothing (\inner -> walker511 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 513; recurses to walker512.
+walker513 :: Core.Term -> Maybe Core.Term
+walker513 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker512 fun) (walker512 arg) (\_ -> walker512 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker512 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker512 body) Nothing (\inner -> walker512 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 514; recurses to walker513.
+walker514 :: Core.Term -> Maybe Core.Term
+walker514 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker513 fun) (walker513 arg) (\_ -> walker513 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker513 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker513 body) Nothing (\inner -> walker513 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 515; recurses to walker514.
+walker515 :: Core.Term -> Maybe Core.Term
+walker515 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker514 fun) (walker514 arg) (\_ -> walker514 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker514 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker514 body) Nothing (\inner -> walker514 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 516; recurses to walker515.
+walker516 :: Core.Term -> Maybe Core.Term
+walker516 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker515 fun) (walker515 arg) (\_ -> walker515 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker515 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker515 body) Nothing (\inner -> walker515 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 517; recurses to walker516.
+walker517 :: Core.Term -> Maybe Core.Term
+walker517 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker516 fun) (walker516 arg) (\_ -> walker516 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker516 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker516 body) Nothing (\inner -> walker516 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 518; recurses to walker517.
+walker518 :: Core.Term -> Maybe Core.Term
+walker518 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker517 fun) (walker517 arg) (\_ -> walker517 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker517 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker517 body) Nothing (\inner -> walker517 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 519; recurses to walker518.
+walker519 :: Core.Term -> Maybe Core.Term
+walker519 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker518 fun) (walker518 arg) (\_ -> walker518 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker518 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker518 body) Nothing (\inner -> walker518 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 52; recurses to walker51.
+walker52 :: Core.Term -> Maybe Core.Term
+walker52 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker51 fun) (walker51 arg) (\_ -> walker51 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker51 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker51 body) Nothing (\inner -> walker51 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 520; recurses to walker519.
+walker520 :: Core.Term -> Maybe Core.Term
+walker520 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker519 fun) (walker519 arg) (\_ -> walker519 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker519 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker519 body) Nothing (\inner -> walker519 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 521; recurses to walker520.
+walker521 :: Core.Term -> Maybe Core.Term
+walker521 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker520 fun) (walker520 arg) (\_ -> walker520 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker520 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker520 body) Nothing (\inner -> walker520 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 522; recurses to walker521.
+walker522 :: Core.Term -> Maybe Core.Term
+walker522 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker521 fun) (walker521 arg) (\_ -> walker521 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker521 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker521 body) Nothing (\inner -> walker521 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 523; recurses to walker522.
+walker523 :: Core.Term -> Maybe Core.Term
+walker523 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker522 fun) (walker522 arg) (\_ -> walker522 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker522 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker522 body) Nothing (\inner -> walker522 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 524; recurses to walker523.
+walker524 :: Core.Term -> Maybe Core.Term
+walker524 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker523 fun) (walker523 arg) (\_ -> walker523 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker523 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker523 body) Nothing (\inner -> walker523 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 525; recurses to walker524.
+walker525 :: Core.Term -> Maybe Core.Term
+walker525 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker524 fun) (walker524 arg) (\_ -> walker524 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker524 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker524 body) Nothing (\inner -> walker524 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 526; recurses to walker525.
+walker526 :: Core.Term -> Maybe Core.Term
+walker526 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker525 fun) (walker525 arg) (\_ -> walker525 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker525 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker525 body) Nothing (\inner -> walker525 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 527; recurses to walker526.
+walker527 :: Core.Term -> Maybe Core.Term
+walker527 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker526 fun) (walker526 arg) (\_ -> walker526 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker526 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker526 body) Nothing (\inner -> walker526 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 528; recurses to walker527.
+walker528 :: Core.Term -> Maybe Core.Term
+walker528 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker527 fun) (walker527 arg) (\_ -> walker527 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker527 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker527 body) Nothing (\inner -> walker527 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 529; recurses to walker528.
+walker529 :: Core.Term -> Maybe Core.Term
+walker529 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker528 fun) (walker528 arg) (\_ -> walker528 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker528 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker528 body) Nothing (\inner -> walker528 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 53; recurses to walker52.
+walker53 :: Core.Term -> Maybe Core.Term
+walker53 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker52 fun) (walker52 arg) (\_ -> walker52 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker52 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker52 body) Nothing (\inner -> walker52 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 530; recurses to walker529.
+walker530 :: Core.Term -> Maybe Core.Term
+walker530 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker529 fun) (walker529 arg) (\_ -> walker529 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker529 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker529 body) Nothing (\inner -> walker529 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 531; recurses to walker530.
+walker531 :: Core.Term -> Maybe Core.Term
+walker531 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker530 fun) (walker530 arg) (\_ -> walker530 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker530 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker530 body) Nothing (\inner -> walker530 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 532; recurses to walker531.
+walker532 :: Core.Term -> Maybe Core.Term
+walker532 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker531 fun) (walker531 arg) (\_ -> walker531 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker531 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker531 body) Nothing (\inner -> walker531 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 533; recurses to walker532.
+walker533 :: Core.Term -> Maybe Core.Term
+walker533 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker532 fun) (walker532 arg) (\_ -> walker532 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker532 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker532 body) Nothing (\inner -> walker532 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 534; recurses to walker533.
+walker534 :: Core.Term -> Maybe Core.Term
+walker534 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker533 fun) (walker533 arg) (\_ -> walker533 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker533 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker533 body) Nothing (\inner -> walker533 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 535; recurses to walker534.
+walker535 :: Core.Term -> Maybe Core.Term
+walker535 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker534 fun) (walker534 arg) (\_ -> walker534 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker534 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker534 body) Nothing (\inner -> walker534 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 536; recurses to walker535.
+walker536 :: Core.Term -> Maybe Core.Term
+walker536 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker535 fun) (walker535 arg) (\_ -> walker535 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker535 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker535 body) Nothing (\inner -> walker535 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 537; recurses to walker536.
+walker537 :: Core.Term -> Maybe Core.Term
+walker537 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker536 fun) (walker536 arg) (\_ -> walker536 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker536 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker536 body) Nothing (\inner -> walker536 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 538; recurses to walker537.
+walker538 :: Core.Term -> Maybe Core.Term
+walker538 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker537 fun) (walker537 arg) (\_ -> walker537 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker537 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker537 body) Nothing (\inner -> walker537 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 539; recurses to walker538.
+walker539 :: Core.Term -> Maybe Core.Term
+walker539 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker538 fun) (walker538 arg) (\_ -> walker538 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker538 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker538 body) Nothing (\inner -> walker538 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 54; recurses to walker53.
+walker54 :: Core.Term -> Maybe Core.Term
+walker54 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker53 fun) (walker53 arg) (\_ -> walker53 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker53 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker53 body) Nothing (\inner -> walker53 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 540; recurses to walker539.
+walker540 :: Core.Term -> Maybe Core.Term
+walker540 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker539 fun) (walker539 arg) (\_ -> walker539 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker539 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker539 body) Nothing (\inner -> walker539 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 541; recurses to walker540.
+walker541 :: Core.Term -> Maybe Core.Term
+walker541 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker540 fun) (walker540 arg) (\_ -> walker540 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker540 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker540 body) Nothing (\inner -> walker540 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 542; recurses to walker541.
+walker542 :: Core.Term -> Maybe Core.Term
+walker542 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker541 fun) (walker541 arg) (\_ -> walker541 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker541 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker541 body) Nothing (\inner -> walker541 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 543; recurses to walker542.
+walker543 :: Core.Term -> Maybe Core.Term
+walker543 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker542 fun) (walker542 arg) (\_ -> walker542 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker542 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker542 body) Nothing (\inner -> walker542 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 544; recurses to walker543.
+walker544 :: Core.Term -> Maybe Core.Term
+walker544 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker543 fun) (walker543 arg) (\_ -> walker543 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker543 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker543 body) Nothing (\inner -> walker543 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 545; recurses to walker544.
+walker545 :: Core.Term -> Maybe Core.Term
+walker545 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker544 fun) (walker544 arg) (\_ -> walker544 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker544 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker544 body) Nothing (\inner -> walker544 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 546; recurses to walker545.
+walker546 :: Core.Term -> Maybe Core.Term
+walker546 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker545 fun) (walker545 arg) (\_ -> walker545 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker545 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker545 body) Nothing (\inner -> walker545 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 547; recurses to walker546.
+walker547 :: Core.Term -> Maybe Core.Term
+walker547 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker546 fun) (walker546 arg) (\_ -> walker546 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker546 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker546 body) Nothing (\inner -> walker546 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 548; recurses to walker547.
+walker548 :: Core.Term -> Maybe Core.Term
+walker548 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker547 fun) (walker547 arg) (\_ -> walker547 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker547 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker547 body) Nothing (\inner -> walker547 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 549; recurses to walker548.
+walker549 :: Core.Term -> Maybe Core.Term
+walker549 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker548 fun) (walker548 arg) (\_ -> walker548 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker548 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker548 body) Nothing (\inner -> walker548 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 55; recurses to walker54.
+walker55 :: Core.Term -> Maybe Core.Term
+walker55 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker54 fun) (walker54 arg) (\_ -> walker54 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker54 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker54 body) Nothing (\inner -> walker54 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 550; recurses to walker549.
+walker550 :: Core.Term -> Maybe Core.Term
+walker550 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker549 fun) (walker549 arg) (\_ -> walker549 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker549 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker549 body) Nothing (\inner -> walker549 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 551; recurses to walker550.
+walker551 :: Core.Term -> Maybe Core.Term
+walker551 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker550 fun) (walker550 arg) (\_ -> walker550 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker550 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker550 body) Nothing (\inner -> walker550 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 552; recurses to walker551.
+walker552 :: Core.Term -> Maybe Core.Term
+walker552 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker551 fun) (walker551 arg) (\_ -> walker551 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker551 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker551 body) Nothing (\inner -> walker551 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 553; recurses to walker552.
+walker553 :: Core.Term -> Maybe Core.Term
+walker553 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker552 fun) (walker552 arg) (\_ -> walker552 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker552 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker552 body) Nothing (\inner -> walker552 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 554; recurses to walker553.
+walker554 :: Core.Term -> Maybe Core.Term
+walker554 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker553 fun) (walker553 arg) (\_ -> walker553 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker553 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker553 body) Nothing (\inner -> walker553 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 555; recurses to walker554.
+walker555 :: Core.Term -> Maybe Core.Term
+walker555 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker554 fun) (walker554 arg) (\_ -> walker554 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker554 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker554 body) Nothing (\inner -> walker554 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 556; recurses to walker555.
+walker556 :: Core.Term -> Maybe Core.Term
+walker556 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker555 fun) (walker555 arg) (\_ -> walker555 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker555 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker555 body) Nothing (\inner -> walker555 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 557; recurses to walker556.
+walker557 :: Core.Term -> Maybe Core.Term
+walker557 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker556 fun) (walker556 arg) (\_ -> walker556 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker556 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker556 body) Nothing (\inner -> walker556 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 558; recurses to walker557.
+walker558 :: Core.Term -> Maybe Core.Term
+walker558 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker557 fun) (walker557 arg) (\_ -> walker557 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker557 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker557 body) Nothing (\inner -> walker557 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 559; recurses to walker558.
+walker559 :: Core.Term -> Maybe Core.Term
+walker559 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker558 fun) (walker558 arg) (\_ -> walker558 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker558 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker558 body) Nothing (\inner -> walker558 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 56; recurses to walker55.
+walker56 :: Core.Term -> Maybe Core.Term
+walker56 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker55 fun) (walker55 arg) (\_ -> walker55 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker55 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker55 body) Nothing (\inner -> walker55 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 560; recurses to walker559.
+walker560 :: Core.Term -> Maybe Core.Term
+walker560 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker559 fun) (walker559 arg) (\_ -> walker559 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker559 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker559 body) Nothing (\inner -> walker559 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 561; recurses to walker560.
+walker561 :: Core.Term -> Maybe Core.Term
+walker561 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker560 fun) (walker560 arg) (\_ -> walker560 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker560 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker560 body) Nothing (\inner -> walker560 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 562; recurses to walker561.
+walker562 :: Core.Term -> Maybe Core.Term
+walker562 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker561 fun) (walker561 arg) (\_ -> walker561 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker561 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker561 body) Nothing (\inner -> walker561 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 563; recurses to walker562.
+walker563 :: Core.Term -> Maybe Core.Term
+walker563 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker562 fun) (walker562 arg) (\_ -> walker562 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker562 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker562 body) Nothing (\inner -> walker562 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 564; recurses to walker563.
+walker564 :: Core.Term -> Maybe Core.Term
+walker564 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker563 fun) (walker563 arg) (\_ -> walker563 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker563 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker563 body) Nothing (\inner -> walker563 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 565; recurses to walker564.
+walker565 :: Core.Term -> Maybe Core.Term
+walker565 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker564 fun) (walker564 arg) (\_ -> walker564 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker564 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker564 body) Nothing (\inner -> walker564 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 566; recurses to walker565.
+walker566 :: Core.Term -> Maybe Core.Term
+walker566 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker565 fun) (walker565 arg) (\_ -> walker565 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker565 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker565 body) Nothing (\inner -> walker565 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 567; recurses to walker566.
+walker567 :: Core.Term -> Maybe Core.Term
+walker567 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker566 fun) (walker566 arg) (\_ -> walker566 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker566 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker566 body) Nothing (\inner -> walker566 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 568; recurses to walker567.
+walker568 :: Core.Term -> Maybe Core.Term
+walker568 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker567 fun) (walker567 arg) (\_ -> walker567 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker567 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker567 body) Nothing (\inner -> walker567 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 569; recurses to walker568.
+walker569 :: Core.Term -> Maybe Core.Term
+walker569 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker568 fun) (walker568 arg) (\_ -> walker568 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker568 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker568 body) Nothing (\inner -> walker568 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 57; recurses to walker56.
+walker57 :: Core.Term -> Maybe Core.Term
+walker57 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker56 fun) (walker56 arg) (\_ -> walker56 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker56 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker56 body) Nothing (\inner -> walker56 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 570; recurses to walker569.
+walker570 :: Core.Term -> Maybe Core.Term
+walker570 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker569 fun) (walker569 arg) (\_ -> walker569 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker569 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker569 body) Nothing (\inner -> walker569 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 571; recurses to walker570.
+walker571 :: Core.Term -> Maybe Core.Term
+walker571 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker570 fun) (walker570 arg) (\_ -> walker570 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker570 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker570 body) Nothing (\inner -> walker570 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 572; recurses to walker571.
+walker572 :: Core.Term -> Maybe Core.Term
+walker572 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker571 fun) (walker571 arg) (\_ -> walker571 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker571 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker571 body) Nothing (\inner -> walker571 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 573; recurses to walker572.
+walker573 :: Core.Term -> Maybe Core.Term
+walker573 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker572 fun) (walker572 arg) (\_ -> walker572 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker572 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker572 body) Nothing (\inner -> walker572 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 574; recurses to walker573.
+walker574 :: Core.Term -> Maybe Core.Term
+walker574 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker573 fun) (walker573 arg) (\_ -> walker573 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker573 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker573 body) Nothing (\inner -> walker573 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 575; recurses to walker574.
+walker575 :: Core.Term -> Maybe Core.Term
+walker575 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker574 fun) (walker574 arg) (\_ -> walker574 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker574 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker574 body) Nothing (\inner -> walker574 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 576; recurses to walker575.
+walker576 :: Core.Term -> Maybe Core.Term
+walker576 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker575 fun) (walker575 arg) (\_ -> walker575 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker575 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker575 body) Nothing (\inner -> walker575 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 577; recurses to walker576.
+walker577 :: Core.Term -> Maybe Core.Term
+walker577 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker576 fun) (walker576 arg) (\_ -> walker576 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker576 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker576 body) Nothing (\inner -> walker576 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 578; recurses to walker577.
+walker578 :: Core.Term -> Maybe Core.Term
+walker578 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker577 fun) (walker577 arg) (\_ -> walker577 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker577 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker577 body) Nothing (\inner -> walker577 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 579; recurses to walker578.
+walker579 :: Core.Term -> Maybe Core.Term
+walker579 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker578 fun) (walker578 arg) (\_ -> walker578 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker578 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker578 body) Nothing (\inner -> walker578 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 58; recurses to walker57.
+walker58 :: Core.Term -> Maybe Core.Term
+walker58 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker57 fun) (walker57 arg) (\_ -> walker57 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker57 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker57 body) Nothing (\inner -> walker57 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 580; recurses to walker579.
+walker580 :: Core.Term -> Maybe Core.Term
+walker580 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker579 fun) (walker579 arg) (\_ -> walker579 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker579 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker579 body) Nothing (\inner -> walker579 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 581; recurses to walker580.
+walker581 :: Core.Term -> Maybe Core.Term
+walker581 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker580 fun) (walker580 arg) (\_ -> walker580 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker580 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker580 body) Nothing (\inner -> walker580 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 582; recurses to walker581.
+walker582 :: Core.Term -> Maybe Core.Term
+walker582 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker581 fun) (walker581 arg) (\_ -> walker581 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker581 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker581 body) Nothing (\inner -> walker581 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 583; recurses to walker582.
+walker583 :: Core.Term -> Maybe Core.Term
+walker583 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker582 fun) (walker582 arg) (\_ -> walker582 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker582 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker582 body) Nothing (\inner -> walker582 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 584; recurses to walker583.
+walker584 :: Core.Term -> Maybe Core.Term
+walker584 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker583 fun) (walker583 arg) (\_ -> walker583 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker583 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker583 body) Nothing (\inner -> walker583 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 585; recurses to walker584.
+walker585 :: Core.Term -> Maybe Core.Term
+walker585 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker584 fun) (walker584 arg) (\_ -> walker584 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker584 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker584 body) Nothing (\inner -> walker584 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 586; recurses to walker585.
+walker586 :: Core.Term -> Maybe Core.Term
+walker586 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker585 fun) (walker585 arg) (\_ -> walker585 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker585 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker585 body) Nothing (\inner -> walker585 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 587; recurses to walker586.
+walker587 :: Core.Term -> Maybe Core.Term
+walker587 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker586 fun) (walker586 arg) (\_ -> walker586 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker586 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker586 body) Nothing (\inner -> walker586 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 588; recurses to walker587.
+walker588 :: Core.Term -> Maybe Core.Term
+walker588 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker587 fun) (walker587 arg) (\_ -> walker587 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker587 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker587 body) Nothing (\inner -> walker587 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 589; recurses to walker588.
+walker589 :: Core.Term -> Maybe Core.Term
+walker589 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker588 fun) (walker588 arg) (\_ -> walker588 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker588 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker588 body) Nothing (\inner -> walker588 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 59; recurses to walker58.
+walker59 :: Core.Term -> Maybe Core.Term
+walker59 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker58 fun) (walker58 arg) (\_ -> walker58 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker58 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker58 body) Nothing (\inner -> walker58 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 590; recurses to walker589.
+walker590 :: Core.Term -> Maybe Core.Term
+walker590 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker589 fun) (walker589 arg) (\_ -> walker589 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker589 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker589 body) Nothing (\inner -> walker589 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 591; recurses to walker590.
+walker591 :: Core.Term -> Maybe Core.Term
+walker591 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker590 fun) (walker590 arg) (\_ -> walker590 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker590 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker590 body) Nothing (\inner -> walker590 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 592; recurses to walker591.
+walker592 :: Core.Term -> Maybe Core.Term
+walker592 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker591 fun) (walker591 arg) (\_ -> walker591 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker591 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker591 body) Nothing (\inner -> walker591 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 593; recurses to walker592.
+walker593 :: Core.Term -> Maybe Core.Term
+walker593 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker592 fun) (walker592 arg) (\_ -> walker592 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker592 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker592 body) Nothing (\inner -> walker592 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 594; recurses to walker593.
+walker594 :: Core.Term -> Maybe Core.Term
+walker594 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker593 fun) (walker593 arg) (\_ -> walker593 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker593 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker593 body) Nothing (\inner -> walker593 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 595; recurses to walker594.
+walker595 :: Core.Term -> Maybe Core.Term
+walker595 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker594 fun) (walker594 arg) (\_ -> walker594 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker594 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker594 body) Nothing (\inner -> walker594 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 596; recurses to walker595.
+walker596 :: Core.Term -> Maybe Core.Term
+walker596 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker595 fun) (walker595 arg) (\_ -> walker595 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker595 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker595 body) Nothing (\inner -> walker595 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 597; recurses to walker596.
+walker597 :: Core.Term -> Maybe Core.Term
+walker597 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker596 fun) (walker596 arg) (\_ -> walker596 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker596 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker596 body) Nothing (\inner -> walker596 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 598; recurses to walker597.
+walker598 :: Core.Term -> Maybe Core.Term
+walker598 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker597 fun) (walker597 arg) (\_ -> walker597 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker597 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker597 body) Nothing (\inner -> walker597 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 599; recurses to walker598.
+walker599 :: Core.Term -> Maybe Core.Term
+walker599 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker598 fun) (walker598 arg) (\_ -> walker598 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker598 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker598 body) Nothing (\inner -> walker598 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 6; recurses to walker5.
+walker6 :: Core.Term -> Maybe Core.Term
+walker6 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker5 fun) (walker5 arg) (\_ -> walker5 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker5 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker5 body) Nothing (\inner -> walker5 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 60; recurses to walker59.
+walker60 :: Core.Term -> Maybe Core.Term
+walker60 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker59 fun) (walker59 arg) (\_ -> walker59 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker59 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker59 body) Nothing (\inner -> walker59 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 600; recurses to walker599.
+walker600 :: Core.Term -> Maybe Core.Term
+walker600 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker599 fun) (walker599 arg) (\_ -> walker599 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker599 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker599 body) Nothing (\inner -> walker599 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 601; recurses to walker600.
+walker601 :: Core.Term -> Maybe Core.Term
+walker601 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker600 fun) (walker600 arg) (\_ -> walker600 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker600 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker600 body) Nothing (\inner -> walker600 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 602; recurses to walker601.
+walker602 :: Core.Term -> Maybe Core.Term
+walker602 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker601 fun) (walker601 arg) (\_ -> walker601 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker601 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker601 body) Nothing (\inner -> walker601 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 603; recurses to walker602.
+walker603 :: Core.Term -> Maybe Core.Term
+walker603 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker602 fun) (walker602 arg) (\_ -> walker602 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker602 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker602 body) Nothing (\inner -> walker602 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 604; recurses to walker603.
+walker604 :: Core.Term -> Maybe Core.Term
+walker604 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker603 fun) (walker603 arg) (\_ -> walker603 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker603 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker603 body) Nothing (\inner -> walker603 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 605; recurses to walker604.
+walker605 :: Core.Term -> Maybe Core.Term
+walker605 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker604 fun) (walker604 arg) (\_ -> walker604 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker604 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker604 body) Nothing (\inner -> walker604 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 606; recurses to walker605.
+walker606 :: Core.Term -> Maybe Core.Term
+walker606 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker605 fun) (walker605 arg) (\_ -> walker605 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker605 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker605 body) Nothing (\inner -> walker605 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 607; recurses to walker606.
+walker607 :: Core.Term -> Maybe Core.Term
+walker607 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker606 fun) (walker606 arg) (\_ -> walker606 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker606 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker606 body) Nothing (\inner -> walker606 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 608; recurses to walker607.
+walker608 :: Core.Term -> Maybe Core.Term
+walker608 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker607 fun) (walker607 arg) (\_ -> walker607 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker607 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker607 body) Nothing (\inner -> walker607 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 609; recurses to walker608.
+walker609 :: Core.Term -> Maybe Core.Term
+walker609 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker608 fun) (walker608 arg) (\_ -> walker608 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker608 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker608 body) Nothing (\inner -> walker608 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 61; recurses to walker60.
+walker61 :: Core.Term -> Maybe Core.Term
+walker61 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker60 fun) (walker60 arg) (\_ -> walker60 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker60 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker60 body) Nothing (\inner -> walker60 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 610; recurses to walker609.
+walker610 :: Core.Term -> Maybe Core.Term
+walker610 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker609 fun) (walker609 arg) (\_ -> walker609 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker609 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker609 body) Nothing (\inner -> walker609 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 611; recurses to walker610.
+walker611 :: Core.Term -> Maybe Core.Term
+walker611 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker610 fun) (walker610 arg) (\_ -> walker610 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker610 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker610 body) Nothing (\inner -> walker610 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 612; recurses to walker611.
+walker612 :: Core.Term -> Maybe Core.Term
+walker612 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker611 fun) (walker611 arg) (\_ -> walker611 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker611 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker611 body) Nothing (\inner -> walker611 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 613; recurses to walker612.
+walker613 :: Core.Term -> Maybe Core.Term
+walker613 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker612 fun) (walker612 arg) (\_ -> walker612 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker612 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker612 body) Nothing (\inner -> walker612 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 614; recurses to walker613.
+walker614 :: Core.Term -> Maybe Core.Term
+walker614 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker613 fun) (walker613 arg) (\_ -> walker613 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker613 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker613 body) Nothing (\inner -> walker613 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 615; recurses to walker614.
+walker615 :: Core.Term -> Maybe Core.Term
+walker615 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker614 fun) (walker614 arg) (\_ -> walker614 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker614 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker614 body) Nothing (\inner -> walker614 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 616; recurses to walker615.
+walker616 :: Core.Term -> Maybe Core.Term
+walker616 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker615 fun) (walker615 arg) (\_ -> walker615 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker615 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker615 body) Nothing (\inner -> walker615 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 617; recurses to walker616.
+walker617 :: Core.Term -> Maybe Core.Term
+walker617 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker616 fun) (walker616 arg) (\_ -> walker616 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker616 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker616 body) Nothing (\inner -> walker616 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 618; recurses to walker617.
+walker618 :: Core.Term -> Maybe Core.Term
+walker618 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker617 fun) (walker617 arg) (\_ -> walker617 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker617 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker617 body) Nothing (\inner -> walker617 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 619; recurses to walker618.
+walker619 :: Core.Term -> Maybe Core.Term
+walker619 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker618 fun) (walker618 arg) (\_ -> walker618 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker618 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker618 body) Nothing (\inner -> walker618 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 62; recurses to walker61.
+walker62 :: Core.Term -> Maybe Core.Term
+walker62 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker61 fun) (walker61 arg) (\_ -> walker61 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker61 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker61 body) Nothing (\inner -> walker61 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 620; recurses to walker619.
+walker620 :: Core.Term -> Maybe Core.Term
+walker620 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker619 fun) (walker619 arg) (\_ -> walker619 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker619 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker619 body) Nothing (\inner -> walker619 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 621; recurses to walker620.
+walker621 :: Core.Term -> Maybe Core.Term
+walker621 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker620 fun) (walker620 arg) (\_ -> walker620 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker620 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker620 body) Nothing (\inner -> walker620 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 622; recurses to walker621.
+walker622 :: Core.Term -> Maybe Core.Term
+walker622 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker621 fun) (walker621 arg) (\_ -> walker621 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker621 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker621 body) Nothing (\inner -> walker621 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 623; recurses to walker622.
+walker623 :: Core.Term -> Maybe Core.Term
+walker623 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker622 fun) (walker622 arg) (\_ -> walker622 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker622 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker622 body) Nothing (\inner -> walker622 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 624; recurses to walker623.
+walker624 :: Core.Term -> Maybe Core.Term
+walker624 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker623 fun) (walker623 arg) (\_ -> walker623 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker623 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker623 body) Nothing (\inner -> walker623 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 625; recurses to walker624.
+walker625 :: Core.Term -> Maybe Core.Term
+walker625 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker624 fun) (walker624 arg) (\_ -> walker624 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker624 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker624 body) Nothing (\inner -> walker624 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 626; recurses to walker625.
+walker626 :: Core.Term -> Maybe Core.Term
+walker626 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker625 fun) (walker625 arg) (\_ -> walker625 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker625 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker625 body) Nothing (\inner -> walker625 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 627; recurses to walker626.
+walker627 :: Core.Term -> Maybe Core.Term
+walker627 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker626 fun) (walker626 arg) (\_ -> walker626 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker626 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker626 body) Nothing (\inner -> walker626 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 628; recurses to walker627.
+walker628 :: Core.Term -> Maybe Core.Term
+walker628 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker627 fun) (walker627 arg) (\_ -> walker627 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker627 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker627 body) Nothing (\inner -> walker627 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 629; recurses to walker628.
+walker629 :: Core.Term -> Maybe Core.Term
+walker629 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker628 fun) (walker628 arg) (\_ -> walker628 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker628 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker628 body) Nothing (\inner -> walker628 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 63; recurses to walker62.
+walker63 :: Core.Term -> Maybe Core.Term
+walker63 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker62 fun) (walker62 arg) (\_ -> walker62 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker62 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker62 body) Nothing (\inner -> walker62 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 630; recurses to walker629.
+walker630 :: Core.Term -> Maybe Core.Term
+walker630 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker629 fun) (walker629 arg) (\_ -> walker629 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker629 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker629 body) Nothing (\inner -> walker629 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 631; recurses to walker630.
+walker631 :: Core.Term -> Maybe Core.Term
+walker631 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker630 fun) (walker630 arg) (\_ -> walker630 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker630 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker630 body) Nothing (\inner -> walker630 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 632; recurses to walker631.
+walker632 :: Core.Term -> Maybe Core.Term
+walker632 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker631 fun) (walker631 arg) (\_ -> walker631 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker631 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker631 body) Nothing (\inner -> walker631 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 633; recurses to walker632.
+walker633 :: Core.Term -> Maybe Core.Term
+walker633 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker632 fun) (walker632 arg) (\_ -> walker632 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker632 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker632 body) Nothing (\inner -> walker632 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 634; recurses to walker633.
+walker634 :: Core.Term -> Maybe Core.Term
+walker634 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker633 fun) (walker633 arg) (\_ -> walker633 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker633 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker633 body) Nothing (\inner -> walker633 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 635; recurses to walker634.
+walker635 :: Core.Term -> Maybe Core.Term
+walker635 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker634 fun) (walker634 arg) (\_ -> walker634 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker634 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker634 body) Nothing (\inner -> walker634 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 636; recurses to walker635.
+walker636 :: Core.Term -> Maybe Core.Term
+walker636 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker635 fun) (walker635 arg) (\_ -> walker635 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker635 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker635 body) Nothing (\inner -> walker635 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 637; recurses to walker636.
+walker637 :: Core.Term -> Maybe Core.Term
+walker637 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker636 fun) (walker636 arg) (\_ -> walker636 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker636 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker636 body) Nothing (\inner -> walker636 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 638; recurses to walker637.
+walker638 :: Core.Term -> Maybe Core.Term
+walker638 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker637 fun) (walker637 arg) (\_ -> walker637 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker637 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker637 body) Nothing (\inner -> walker637 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 639; recurses to walker638.
+walker639 :: Core.Term -> Maybe Core.Term
+walker639 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker638 fun) (walker638 arg) (\_ -> walker638 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker638 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker638 body) Nothing (\inner -> walker638 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 64; recurses to walker63.
+walker64 :: Core.Term -> Maybe Core.Term
+walker64 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker63 fun) (walker63 arg) (\_ -> walker63 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker63 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker63 body) Nothing (\inner -> walker63 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 640; recurses to walker639.
+walker640 :: Core.Term -> Maybe Core.Term
+walker640 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker639 fun) (walker639 arg) (\_ -> walker639 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker639 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker639 body) Nothing (\inner -> walker639 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 641; recurses to walker640.
+walker641 :: Core.Term -> Maybe Core.Term
+walker641 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker640 fun) (walker640 arg) (\_ -> walker640 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker640 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker640 body) Nothing (\inner -> walker640 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 642; recurses to walker641.
+walker642 :: Core.Term -> Maybe Core.Term
+walker642 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker641 fun) (walker641 arg) (\_ -> walker641 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker641 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker641 body) Nothing (\inner -> walker641 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 643; recurses to walker642.
+walker643 :: Core.Term -> Maybe Core.Term
+walker643 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker642 fun) (walker642 arg) (\_ -> walker642 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker642 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker642 body) Nothing (\inner -> walker642 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 644; recurses to walker643.
+walker644 :: Core.Term -> Maybe Core.Term
+walker644 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker643 fun) (walker643 arg) (\_ -> walker643 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker643 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker643 body) Nothing (\inner -> walker643 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 645; recurses to walker644.
+walker645 :: Core.Term -> Maybe Core.Term
+walker645 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker644 fun) (walker644 arg) (\_ -> walker644 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker644 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker644 body) Nothing (\inner -> walker644 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 646; recurses to walker645.
+walker646 :: Core.Term -> Maybe Core.Term
+walker646 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker645 fun) (walker645 arg) (\_ -> walker645 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker645 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker645 body) Nothing (\inner -> walker645 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 647; recurses to walker646.
+walker647 :: Core.Term -> Maybe Core.Term
+walker647 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker646 fun) (walker646 arg) (\_ -> walker646 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker646 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker646 body) Nothing (\inner -> walker646 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 648; recurses to walker647.
+walker648 :: Core.Term -> Maybe Core.Term
+walker648 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker647 fun) (walker647 arg) (\_ -> walker647 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker647 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker647 body) Nothing (\inner -> walker647 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 649; recurses to walker648.
+walker649 :: Core.Term -> Maybe Core.Term
+walker649 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker648 fun) (walker648 arg) (\_ -> walker648 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker648 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker648 body) Nothing (\inner -> walker648 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 65; recurses to walker64.
+walker65 :: Core.Term -> Maybe Core.Term
+walker65 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker64 fun) (walker64 arg) (\_ -> walker64 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker64 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker64 body) Nothing (\inner -> walker64 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 650; recurses to walker649.
+walker650 :: Core.Term -> Maybe Core.Term
+walker650 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker649 fun) (walker649 arg) (\_ -> walker649 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker649 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker649 body) Nothing (\inner -> walker649 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 651; recurses to walker650.
+walker651 :: Core.Term -> Maybe Core.Term
+walker651 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker650 fun) (walker650 arg) (\_ -> walker650 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker650 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker650 body) Nothing (\inner -> walker650 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 652; recurses to walker651.
+walker652 :: Core.Term -> Maybe Core.Term
+walker652 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker651 fun) (walker651 arg) (\_ -> walker651 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker651 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker651 body) Nothing (\inner -> walker651 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 653; recurses to walker652.
+walker653 :: Core.Term -> Maybe Core.Term
+walker653 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker652 fun) (walker652 arg) (\_ -> walker652 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker652 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker652 body) Nothing (\inner -> walker652 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 654; recurses to walker653.
+walker654 :: Core.Term -> Maybe Core.Term
+walker654 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker653 fun) (walker653 arg) (\_ -> walker653 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker653 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker653 body) Nothing (\inner -> walker653 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 655; recurses to walker654.
+walker655 :: Core.Term -> Maybe Core.Term
+walker655 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker654 fun) (walker654 arg) (\_ -> walker654 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker654 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker654 body) Nothing (\inner -> walker654 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 656; recurses to walker655.
+walker656 :: Core.Term -> Maybe Core.Term
+walker656 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker655 fun) (walker655 arg) (\_ -> walker655 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker655 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker655 body) Nothing (\inner -> walker655 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 657; recurses to walker656.
+walker657 :: Core.Term -> Maybe Core.Term
+walker657 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker656 fun) (walker656 arg) (\_ -> walker656 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker656 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker656 body) Nothing (\inner -> walker656 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 658; recurses to walker657.
+walker658 :: Core.Term -> Maybe Core.Term
+walker658 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker657 fun) (walker657 arg) (\_ -> walker657 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker657 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker657 body) Nothing (\inner -> walker657 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 659; recurses to walker658.
+walker659 :: Core.Term -> Maybe Core.Term
+walker659 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker658 fun) (walker658 arg) (\_ -> walker658 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker658 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker658 body) Nothing (\inner -> walker658 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 66; recurses to walker65.
+walker66 :: Core.Term -> Maybe Core.Term
+walker66 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker65 fun) (walker65 arg) (\_ -> walker65 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker65 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker65 body) Nothing (\inner -> walker65 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 660; recurses to walker659.
+walker660 :: Core.Term -> Maybe Core.Term
+walker660 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker659 fun) (walker659 arg) (\_ -> walker659 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker659 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker659 body) Nothing (\inner -> walker659 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 661; recurses to walker660.
+walker661 :: Core.Term -> Maybe Core.Term
+walker661 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker660 fun) (walker660 arg) (\_ -> walker660 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker660 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker660 body) Nothing (\inner -> walker660 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 662; recurses to walker661.
+walker662 :: Core.Term -> Maybe Core.Term
+walker662 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker661 fun) (walker661 arg) (\_ -> walker661 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker661 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker661 body) Nothing (\inner -> walker661 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 663; recurses to walker662.
+walker663 :: Core.Term -> Maybe Core.Term
+walker663 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker662 fun) (walker662 arg) (\_ -> walker662 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker662 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker662 body) Nothing (\inner -> walker662 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 664; recurses to walker663.
+walker664 :: Core.Term -> Maybe Core.Term
+walker664 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker663 fun) (walker663 arg) (\_ -> walker663 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker663 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker663 body) Nothing (\inner -> walker663 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 665; recurses to walker664.
+walker665 :: Core.Term -> Maybe Core.Term
+walker665 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker664 fun) (walker664 arg) (\_ -> walker664 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker664 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker664 body) Nothing (\inner -> walker664 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 666; recurses to walker665.
+walker666 :: Core.Term -> Maybe Core.Term
+walker666 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker665 fun) (walker665 arg) (\_ -> walker665 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker665 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker665 body) Nothing (\inner -> walker665 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 667; recurses to walker666.
+walker667 :: Core.Term -> Maybe Core.Term
+walker667 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker666 fun) (walker666 arg) (\_ -> walker666 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker666 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker666 body) Nothing (\inner -> walker666 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 668; recurses to walker667.
+walker668 :: Core.Term -> Maybe Core.Term
+walker668 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker667 fun) (walker667 arg) (\_ -> walker667 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker667 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker667 body) Nothing (\inner -> walker667 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 669; recurses to walker668.
+walker669 :: Core.Term -> Maybe Core.Term
+walker669 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker668 fun) (walker668 arg) (\_ -> walker668 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker668 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker668 body) Nothing (\inner -> walker668 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 67; recurses to walker66.
+walker67 :: Core.Term -> Maybe Core.Term
+walker67 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker66 fun) (walker66 arg) (\_ -> walker66 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker66 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker66 body) Nothing (\inner -> walker66 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 670; recurses to walker669.
+walker670 :: Core.Term -> Maybe Core.Term
+walker670 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker669 fun) (walker669 arg) (\_ -> walker669 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker669 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker669 body) Nothing (\inner -> walker669 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 671; recurses to walker670.
+walker671 :: Core.Term -> Maybe Core.Term
+walker671 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker670 fun) (walker670 arg) (\_ -> walker670 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker670 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker670 body) Nothing (\inner -> walker670 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 672; recurses to walker671.
+walker672 :: Core.Term -> Maybe Core.Term
+walker672 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker671 fun) (walker671 arg) (\_ -> walker671 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker671 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker671 body) Nothing (\inner -> walker671 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 673; recurses to walker672.
+walker673 :: Core.Term -> Maybe Core.Term
+walker673 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker672 fun) (walker672 arg) (\_ -> walker672 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker672 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker672 body) Nothing (\inner -> walker672 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 674; recurses to walker673.
+walker674 :: Core.Term -> Maybe Core.Term
+walker674 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker673 fun) (walker673 arg) (\_ -> walker673 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker673 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker673 body) Nothing (\inner -> walker673 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 675; recurses to walker674.
+walker675 :: Core.Term -> Maybe Core.Term
+walker675 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker674 fun) (walker674 arg) (\_ -> walker674 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker674 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker674 body) Nothing (\inner -> walker674 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 676; recurses to walker675.
+walker676 :: Core.Term -> Maybe Core.Term
+walker676 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker675 fun) (walker675 arg) (\_ -> walker675 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker675 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker675 body) Nothing (\inner -> walker675 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 677; recurses to walker676.
+walker677 :: Core.Term -> Maybe Core.Term
+walker677 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker676 fun) (walker676 arg) (\_ -> walker676 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker676 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker676 body) Nothing (\inner -> walker676 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 678; recurses to walker677.
+walker678 :: Core.Term -> Maybe Core.Term
+walker678 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker677 fun) (walker677 arg) (\_ -> walker677 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker677 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker677 body) Nothing (\inner -> walker677 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 679; recurses to walker678.
+walker679 :: Core.Term -> Maybe Core.Term
+walker679 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker678 fun) (walker678 arg) (\_ -> walker678 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker678 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker678 body) Nothing (\inner -> walker678 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 68; recurses to walker67.
+walker68 :: Core.Term -> Maybe Core.Term
+walker68 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker67 fun) (walker67 arg) (\_ -> walker67 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker67 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker67 body) Nothing (\inner -> walker67 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 680; recurses to walker679.
+walker680 :: Core.Term -> Maybe Core.Term
+walker680 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker679 fun) (walker679 arg) (\_ -> walker679 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker679 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker679 body) Nothing (\inner -> walker679 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 681; recurses to walker680.
+walker681 :: Core.Term -> Maybe Core.Term
+walker681 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker680 fun) (walker680 arg) (\_ -> walker680 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker680 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker680 body) Nothing (\inner -> walker680 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 682; recurses to walker681.
+walker682 :: Core.Term -> Maybe Core.Term
+walker682 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker681 fun) (walker681 arg) (\_ -> walker681 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker681 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker681 body) Nothing (\inner -> walker681 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 683; recurses to walker682.
+walker683 :: Core.Term -> Maybe Core.Term
+walker683 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker682 fun) (walker682 arg) (\_ -> walker682 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker682 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker682 body) Nothing (\inner -> walker682 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 684; recurses to walker683.
+walker684 :: Core.Term -> Maybe Core.Term
+walker684 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker683 fun) (walker683 arg) (\_ -> walker683 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker683 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker683 body) Nothing (\inner -> walker683 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 685; recurses to walker684.
+walker685 :: Core.Term -> Maybe Core.Term
+walker685 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker684 fun) (walker684 arg) (\_ -> walker684 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker684 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker684 body) Nothing (\inner -> walker684 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 686; recurses to walker685.
+walker686 :: Core.Term -> Maybe Core.Term
+walker686 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker685 fun) (walker685 arg) (\_ -> walker685 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker685 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker685 body) Nothing (\inner -> walker685 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 687; recurses to walker686.
+walker687 :: Core.Term -> Maybe Core.Term
+walker687 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker686 fun) (walker686 arg) (\_ -> walker686 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker686 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker686 body) Nothing (\inner -> walker686 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 688; recurses to walker687.
+walker688 :: Core.Term -> Maybe Core.Term
+walker688 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker687 fun) (walker687 arg) (\_ -> walker687 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker687 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker687 body) Nothing (\inner -> walker687 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 689; recurses to walker688.
+walker689 :: Core.Term -> Maybe Core.Term
+walker689 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker688 fun) (walker688 arg) (\_ -> walker688 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker688 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker688 body) Nothing (\inner -> walker688 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 69; recurses to walker68.
+walker69 :: Core.Term -> Maybe Core.Term
+walker69 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker68 fun) (walker68 arg) (\_ -> walker68 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker68 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker68 body) Nothing (\inner -> walker68 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 690; recurses to walker689.
+walker690 :: Core.Term -> Maybe Core.Term
+walker690 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker689 fun) (walker689 arg) (\_ -> walker689 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker689 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker689 body) Nothing (\inner -> walker689 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 691; recurses to walker690.
+walker691 :: Core.Term -> Maybe Core.Term
+walker691 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker690 fun) (walker690 arg) (\_ -> walker690 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker690 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker690 body) Nothing (\inner -> walker690 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 692; recurses to walker691.
+walker692 :: Core.Term -> Maybe Core.Term
+walker692 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker691 fun) (walker691 arg) (\_ -> walker691 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker691 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker691 body) Nothing (\inner -> walker691 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 693; recurses to walker692.
+walker693 :: Core.Term -> Maybe Core.Term
+walker693 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker692 fun) (walker692 arg) (\_ -> walker692 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker692 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker692 body) Nothing (\inner -> walker692 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 694; recurses to walker693.
+walker694 :: Core.Term -> Maybe Core.Term
+walker694 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker693 fun) (walker693 arg) (\_ -> walker693 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker693 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker693 body) Nothing (\inner -> walker693 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 695; recurses to walker694.
+walker695 :: Core.Term -> Maybe Core.Term
+walker695 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker694 fun) (walker694 arg) (\_ -> walker694 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker694 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker694 body) Nothing (\inner -> walker694 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 696; recurses to walker695.
+walker696 :: Core.Term -> Maybe Core.Term
+walker696 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker695 fun) (walker695 arg) (\_ -> walker695 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker695 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker695 body) Nothing (\inner -> walker695 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 697; recurses to walker696.
+walker697 :: Core.Term -> Maybe Core.Term
+walker697 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker696 fun) (walker696 arg) (\_ -> walker696 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker696 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker696 body) Nothing (\inner -> walker696 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 698; recurses to walker697.
+walker698 :: Core.Term -> Maybe Core.Term
+walker698 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker697 fun) (walker697 arg) (\_ -> walker697 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker697 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker697 body) Nothing (\inner -> walker697 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 699; recurses to walker698.
+walker699 :: Core.Term -> Maybe Core.Term
+walker699 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker698 fun) (walker698 arg) (\_ -> walker698 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker698 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker698 body) Nothing (\inner -> walker698 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 7; recurses to walker6.
+walker7 :: Core.Term -> Maybe Core.Term
+walker7 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker6 fun) (walker6 arg) (\_ -> walker6 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker6 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker6 body) Nothing (\inner -> walker6 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 70; recurses to walker69.
+walker70 :: Core.Term -> Maybe Core.Term
+walker70 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker69 fun) (walker69 arg) (\_ -> walker69 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker69 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker69 body) Nothing (\inner -> walker69 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 700; recurses to walker699.
+walker700 :: Core.Term -> Maybe Core.Term
+walker700 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker699 fun) (walker699 arg) (\_ -> walker699 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker699 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker699 body) Nothing (\inner -> walker699 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 701; recurses to walker700.
+walker701 :: Core.Term -> Maybe Core.Term
+walker701 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker700 fun) (walker700 arg) (\_ -> walker700 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker700 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker700 body) Nothing (\inner -> walker700 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 702; recurses to walker701.
+walker702 :: Core.Term -> Maybe Core.Term
+walker702 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker701 fun) (walker701 arg) (\_ -> walker701 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker701 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker701 body) Nothing (\inner -> walker701 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 703; recurses to walker702.
+walker703 :: Core.Term -> Maybe Core.Term
+walker703 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker702 fun) (walker702 arg) (\_ -> walker702 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker702 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker702 body) Nothing (\inner -> walker702 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 704; recurses to walker703.
+walker704 :: Core.Term -> Maybe Core.Term
+walker704 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker703 fun) (walker703 arg) (\_ -> walker703 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker703 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker703 body) Nothing (\inner -> walker703 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 705; recurses to walker704.
+walker705 :: Core.Term -> Maybe Core.Term
+walker705 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker704 fun) (walker704 arg) (\_ -> walker704 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker704 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker704 body) Nothing (\inner -> walker704 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 706; recurses to walker705.
+walker706 :: Core.Term -> Maybe Core.Term
+walker706 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker705 fun) (walker705 arg) (\_ -> walker705 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker705 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker705 body) Nothing (\inner -> walker705 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 707; recurses to walker706.
+walker707 :: Core.Term -> Maybe Core.Term
+walker707 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker706 fun) (walker706 arg) (\_ -> walker706 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker706 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker706 body) Nothing (\inner -> walker706 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 708; recurses to walker707.
+walker708 :: Core.Term -> Maybe Core.Term
+walker708 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker707 fun) (walker707 arg) (\_ -> walker707 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker707 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker707 body) Nothing (\inner -> walker707 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 709; recurses to walker708.
+walker709 :: Core.Term -> Maybe Core.Term
+walker709 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker708 fun) (walker708 arg) (\_ -> walker708 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker708 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker708 body) Nothing (\inner -> walker708 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 71; recurses to walker70.
+walker71 :: Core.Term -> Maybe Core.Term
+walker71 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker70 fun) (walker70 arg) (\_ -> walker70 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker70 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker70 body) Nothing (\inner -> walker70 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 710; recurses to walker709.
+walker710 :: Core.Term -> Maybe Core.Term
+walker710 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker709 fun) (walker709 arg) (\_ -> walker709 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker709 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker709 body) Nothing (\inner -> walker709 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 711; recurses to walker710.
+walker711 :: Core.Term -> Maybe Core.Term
+walker711 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker710 fun) (walker710 arg) (\_ -> walker710 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker710 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker710 body) Nothing (\inner -> walker710 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 712; recurses to walker711.
+walker712 :: Core.Term -> Maybe Core.Term
+walker712 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker711 fun) (walker711 arg) (\_ -> walker711 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker711 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker711 body) Nothing (\inner -> walker711 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 713; recurses to walker712.
+walker713 :: Core.Term -> Maybe Core.Term
+walker713 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker712 fun) (walker712 arg) (\_ -> walker712 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker712 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker712 body) Nothing (\inner -> walker712 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 714; recurses to walker713.
+walker714 :: Core.Term -> Maybe Core.Term
+walker714 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker713 fun) (walker713 arg) (\_ -> walker713 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker713 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker713 body) Nothing (\inner -> walker713 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 715; recurses to walker714.
+walker715 :: Core.Term -> Maybe Core.Term
+walker715 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker714 fun) (walker714 arg) (\_ -> walker714 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker714 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker714 body) Nothing (\inner -> walker714 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 716; recurses to walker715.
+walker716 :: Core.Term -> Maybe Core.Term
+walker716 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker715 fun) (walker715 arg) (\_ -> walker715 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker715 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker715 body) Nothing (\inner -> walker715 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 717; recurses to walker716.
+walker717 :: Core.Term -> Maybe Core.Term
+walker717 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker716 fun) (walker716 arg) (\_ -> walker716 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker716 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker716 body) Nothing (\inner -> walker716 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 718; recurses to walker717.
+walker718 :: Core.Term -> Maybe Core.Term
+walker718 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker717 fun) (walker717 arg) (\_ -> walker717 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker717 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker717 body) Nothing (\inner -> walker717 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 719; recurses to walker718.
+walker719 :: Core.Term -> Maybe Core.Term
+walker719 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker718 fun) (walker718 arg) (\_ -> walker718 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker718 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker718 body) Nothing (\inner -> walker718 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 72; recurses to walker71.
+walker72 :: Core.Term -> Maybe Core.Term
+walker72 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker71 fun) (walker71 arg) (\_ -> walker71 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker71 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker71 body) Nothing (\inner -> walker71 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 720; recurses to walker719.
+walker720 :: Core.Term -> Maybe Core.Term
+walker720 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker719 fun) (walker719 arg) (\_ -> walker719 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker719 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker719 body) Nothing (\inner -> walker719 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 721; recurses to walker720.
+walker721 :: Core.Term -> Maybe Core.Term
+walker721 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker720 fun) (walker720 arg) (\_ -> walker720 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker720 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker720 body) Nothing (\inner -> walker720 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 722; recurses to walker721.
+walker722 :: Core.Term -> Maybe Core.Term
+walker722 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker721 fun) (walker721 arg) (\_ -> walker721 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker721 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker721 body) Nothing (\inner -> walker721 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 723; recurses to walker722.
+walker723 :: Core.Term -> Maybe Core.Term
+walker723 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker722 fun) (walker722 arg) (\_ -> walker722 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker722 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker722 body) Nothing (\inner -> walker722 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 724; recurses to walker723.
+walker724 :: Core.Term -> Maybe Core.Term
+walker724 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker723 fun) (walker723 arg) (\_ -> walker723 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker723 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker723 body) Nothing (\inner -> walker723 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 725; recurses to walker724.
+walker725 :: Core.Term -> Maybe Core.Term
+walker725 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker724 fun) (walker724 arg) (\_ -> walker724 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker724 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker724 body) Nothing (\inner -> walker724 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 726; recurses to walker725.
+walker726 :: Core.Term -> Maybe Core.Term
+walker726 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker725 fun) (walker725 arg) (\_ -> walker725 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker725 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker725 body) Nothing (\inner -> walker725 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 727; recurses to walker726.
+walker727 :: Core.Term -> Maybe Core.Term
+walker727 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker726 fun) (walker726 arg) (\_ -> walker726 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker726 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker726 body) Nothing (\inner -> walker726 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 728; recurses to walker727.
+walker728 :: Core.Term -> Maybe Core.Term
+walker728 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker727 fun) (walker727 arg) (\_ -> walker727 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker727 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker727 body) Nothing (\inner -> walker727 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 729; recurses to walker728.
+walker729 :: Core.Term -> Maybe Core.Term
+walker729 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker728 fun) (walker728 arg) (\_ -> walker728 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker728 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker728 body) Nothing (\inner -> walker728 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 73; recurses to walker72.
+walker73 :: Core.Term -> Maybe Core.Term
+walker73 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker72 fun) (walker72 arg) (\_ -> walker72 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker72 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker72 body) Nothing (\inner -> walker72 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 730; recurses to walker729.
+walker730 :: Core.Term -> Maybe Core.Term
+walker730 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker729 fun) (walker729 arg) (\_ -> walker729 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker729 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker729 body) Nothing (\inner -> walker729 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 731; recurses to walker730.
+walker731 :: Core.Term -> Maybe Core.Term
+walker731 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker730 fun) (walker730 arg) (\_ -> walker730 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker730 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker730 body) Nothing (\inner -> walker730 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 732; recurses to walker731.
+walker732 :: Core.Term -> Maybe Core.Term
+walker732 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker731 fun) (walker731 arg) (\_ -> walker731 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker731 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker731 body) Nothing (\inner -> walker731 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 733; recurses to walker732.
+walker733 :: Core.Term -> Maybe Core.Term
+walker733 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker732 fun) (walker732 arg) (\_ -> walker732 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker732 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker732 body) Nothing (\inner -> walker732 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 734; recurses to walker733.
+walker734 :: Core.Term -> Maybe Core.Term
+walker734 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker733 fun) (walker733 arg) (\_ -> walker733 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker733 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker733 body) Nothing (\inner -> walker733 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 735; recurses to walker734.
+walker735 :: Core.Term -> Maybe Core.Term
+walker735 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker734 fun) (walker734 arg) (\_ -> walker734 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker734 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker734 body) Nothing (\inner -> walker734 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 736; recurses to walker735.
+walker736 :: Core.Term -> Maybe Core.Term
+walker736 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker735 fun) (walker735 arg) (\_ -> walker735 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker735 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker735 body) Nothing (\inner -> walker735 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 737; recurses to walker736.
+walker737 :: Core.Term -> Maybe Core.Term
+walker737 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker736 fun) (walker736 arg) (\_ -> walker736 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker736 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker736 body) Nothing (\inner -> walker736 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 738; recurses to walker737.
+walker738 :: Core.Term -> Maybe Core.Term
+walker738 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker737 fun) (walker737 arg) (\_ -> walker737 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker737 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker737 body) Nothing (\inner -> walker737 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 739; recurses to walker738.
+walker739 :: Core.Term -> Maybe Core.Term
+walker739 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker738 fun) (walker738 arg) (\_ -> walker738 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker738 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker738 body) Nothing (\inner -> walker738 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 74; recurses to walker73.
+walker74 :: Core.Term -> Maybe Core.Term
+walker74 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker73 fun) (walker73 arg) (\_ -> walker73 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker73 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker73 body) Nothing (\inner -> walker73 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 740; recurses to walker739.
+walker740 :: Core.Term -> Maybe Core.Term
+walker740 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker739 fun) (walker739 arg) (\_ -> walker739 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker739 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker739 body) Nothing (\inner -> walker739 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 741; recurses to walker740.
+walker741 :: Core.Term -> Maybe Core.Term
+walker741 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker740 fun) (walker740 arg) (\_ -> walker740 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker740 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker740 body) Nothing (\inner -> walker740 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 742; recurses to walker741.
+walker742 :: Core.Term -> Maybe Core.Term
+walker742 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker741 fun) (walker741 arg) (\_ -> walker741 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker741 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker741 body) Nothing (\inner -> walker741 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 743; recurses to walker742.
+walker743 :: Core.Term -> Maybe Core.Term
+walker743 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker742 fun) (walker742 arg) (\_ -> walker742 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker742 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker742 body) Nothing (\inner -> walker742 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 744; recurses to walker743.
+walker744 :: Core.Term -> Maybe Core.Term
+walker744 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker743 fun) (walker743 arg) (\_ -> walker743 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker743 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker743 body) Nothing (\inner -> walker743 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 745; recurses to walker744.
+walker745 :: Core.Term -> Maybe Core.Term
+walker745 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker744 fun) (walker744 arg) (\_ -> walker744 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker744 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker744 body) Nothing (\inner -> walker744 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 746; recurses to walker745.
+walker746 :: Core.Term -> Maybe Core.Term
+walker746 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker745 fun) (walker745 arg) (\_ -> walker745 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker745 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker745 body) Nothing (\inner -> walker745 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 747; recurses to walker746.
+walker747 :: Core.Term -> Maybe Core.Term
+walker747 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker746 fun) (walker746 arg) (\_ -> walker746 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker746 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker746 body) Nothing (\inner -> walker746 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 748; recurses to walker747.
+walker748 :: Core.Term -> Maybe Core.Term
+walker748 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker747 fun) (walker747 arg) (\_ -> walker747 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker747 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker747 body) Nothing (\inner -> walker747 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 749; recurses to walker748.
+walker749 :: Core.Term -> Maybe Core.Term
+walker749 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker748 fun) (walker748 arg) (\_ -> walker748 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker748 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker748 body) Nothing (\inner -> walker748 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 75; recurses to walker74.
+walker75 :: Core.Term -> Maybe Core.Term
+walker75 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker74 fun) (walker74 arg) (\_ -> walker74 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker74 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker74 body) Nothing (\inner -> walker74 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 750; recurses to walker749.
+walker750 :: Core.Term -> Maybe Core.Term
+walker750 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker749 fun) (walker749 arg) (\_ -> walker749 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker749 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker749 body) Nothing (\inner -> walker749 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 751; recurses to walker750.
+walker751 :: Core.Term -> Maybe Core.Term
+walker751 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker750 fun) (walker750 arg) (\_ -> walker750 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker750 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker750 body) Nothing (\inner -> walker750 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 752; recurses to walker751.
+walker752 :: Core.Term -> Maybe Core.Term
+walker752 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker751 fun) (walker751 arg) (\_ -> walker751 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker751 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker751 body) Nothing (\inner -> walker751 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 753; recurses to walker752.
+walker753 :: Core.Term -> Maybe Core.Term
+walker753 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker752 fun) (walker752 arg) (\_ -> walker752 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker752 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker752 body) Nothing (\inner -> walker752 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 754; recurses to walker753.
+walker754 :: Core.Term -> Maybe Core.Term
+walker754 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker753 fun) (walker753 arg) (\_ -> walker753 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker753 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker753 body) Nothing (\inner -> walker753 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 755; recurses to walker754.
+walker755 :: Core.Term -> Maybe Core.Term
+walker755 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker754 fun) (walker754 arg) (\_ -> walker754 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker754 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker754 body) Nothing (\inner -> walker754 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 756; recurses to walker755.
+walker756 :: Core.Term -> Maybe Core.Term
+walker756 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker755 fun) (walker755 arg) (\_ -> walker755 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker755 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker755 body) Nothing (\inner -> walker755 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 757; recurses to walker756.
+walker757 :: Core.Term -> Maybe Core.Term
+walker757 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker756 fun) (walker756 arg) (\_ -> walker756 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker756 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker756 body) Nothing (\inner -> walker756 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 758; recurses to walker757.
+walker758 :: Core.Term -> Maybe Core.Term
+walker758 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker757 fun) (walker757 arg) (\_ -> walker757 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker757 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker757 body) Nothing (\inner -> walker757 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 759; recurses to walker758.
+walker759 :: Core.Term -> Maybe Core.Term
+walker759 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker758 fun) (walker758 arg) (\_ -> walker758 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker758 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker758 body) Nothing (\inner -> walker758 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 76; recurses to walker75.
+walker76 :: Core.Term -> Maybe Core.Term
+walker76 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker75 fun) (walker75 arg) (\_ -> walker75 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker75 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker75 body) Nothing (\inner -> walker75 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 760; recurses to walker759.
+walker760 :: Core.Term -> Maybe Core.Term
+walker760 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker759 fun) (walker759 arg) (\_ -> walker759 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker759 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker759 body) Nothing (\inner -> walker759 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 761; recurses to walker760.
+walker761 :: Core.Term -> Maybe Core.Term
+walker761 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker760 fun) (walker760 arg) (\_ -> walker760 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker760 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker760 body) Nothing (\inner -> walker760 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 762; recurses to walker761.
+walker762 :: Core.Term -> Maybe Core.Term
+walker762 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker761 fun) (walker761 arg) (\_ -> walker761 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker761 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker761 body) Nothing (\inner -> walker761 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 763; recurses to walker762.
+walker763 :: Core.Term -> Maybe Core.Term
+walker763 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker762 fun) (walker762 arg) (\_ -> walker762 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker762 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker762 body) Nothing (\inner -> walker762 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 764; recurses to walker763.
+walker764 :: Core.Term -> Maybe Core.Term
+walker764 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker763 fun) (walker763 arg) (\_ -> walker763 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker763 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker763 body) Nothing (\inner -> walker763 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 765; recurses to walker764.
+walker765 :: Core.Term -> Maybe Core.Term
+walker765 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker764 fun) (walker764 arg) (\_ -> walker764 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker764 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker764 body) Nothing (\inner -> walker764 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 766; recurses to walker765.
+walker766 :: Core.Term -> Maybe Core.Term
+walker766 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker765 fun) (walker765 arg) (\_ -> walker765 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker765 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker765 body) Nothing (\inner -> walker765 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 767; recurses to walker766.
+walker767 :: Core.Term -> Maybe Core.Term
+walker767 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker766 fun) (walker766 arg) (\_ -> walker766 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker766 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker766 body) Nothing (\inner -> walker766 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 768; recurses to walker767.
+walker768 :: Core.Term -> Maybe Core.Term
+walker768 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker767 fun) (walker767 arg) (\_ -> walker767 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker767 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker767 body) Nothing (\inner -> walker767 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 769; recurses to walker768.
+walker769 :: Core.Term -> Maybe Core.Term
+walker769 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker768 fun) (walker768 arg) (\_ -> walker768 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker768 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker768 body) Nothing (\inner -> walker768 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 77; recurses to walker76.
+walker77 :: Core.Term -> Maybe Core.Term
+walker77 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker76 fun) (walker76 arg) (\_ -> walker76 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker76 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker76 body) Nothing (\inner -> walker76 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 770; recurses to walker769.
+walker770 :: Core.Term -> Maybe Core.Term
+walker770 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker769 fun) (walker769 arg) (\_ -> walker769 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker769 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker769 body) Nothing (\inner -> walker769 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 771; recurses to walker770.
+walker771 :: Core.Term -> Maybe Core.Term
+walker771 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker770 fun) (walker770 arg) (\_ -> walker770 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker770 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker770 body) Nothing (\inner -> walker770 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 772; recurses to walker771.
+walker772 :: Core.Term -> Maybe Core.Term
+walker772 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker771 fun) (walker771 arg) (\_ -> walker771 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker771 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker771 body) Nothing (\inner -> walker771 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 773; recurses to walker772.
+walker773 :: Core.Term -> Maybe Core.Term
+walker773 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker772 fun) (walker772 arg) (\_ -> walker772 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker772 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker772 body) Nothing (\inner -> walker772 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 774; recurses to walker773.
+walker774 :: Core.Term -> Maybe Core.Term
+walker774 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker773 fun) (walker773 arg) (\_ -> walker773 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker773 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker773 body) Nothing (\inner -> walker773 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 775; recurses to walker774.
+walker775 :: Core.Term -> Maybe Core.Term
+walker775 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker774 fun) (walker774 arg) (\_ -> walker774 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker774 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker774 body) Nothing (\inner -> walker774 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 776; recurses to walker775.
+walker776 :: Core.Term -> Maybe Core.Term
+walker776 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker775 fun) (walker775 arg) (\_ -> walker775 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker775 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker775 body) Nothing (\inner -> walker775 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 777; recurses to walker776.
+walker777 :: Core.Term -> Maybe Core.Term
+walker777 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker776 fun) (walker776 arg) (\_ -> walker776 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker776 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker776 body) Nothing (\inner -> walker776 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 778; recurses to walker777.
+walker778 :: Core.Term -> Maybe Core.Term
+walker778 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker777 fun) (walker777 arg) (\_ -> walker777 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker777 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker777 body) Nothing (\inner -> walker777 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 779; recurses to walker778.
+walker779 :: Core.Term -> Maybe Core.Term
+walker779 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker778 fun) (walker778 arg) (\_ -> walker778 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker778 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker778 body) Nothing (\inner -> walker778 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 78; recurses to walker77.
+walker78 :: Core.Term -> Maybe Core.Term
+walker78 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker77 fun) (walker77 arg) (\_ -> walker77 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker77 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker77 body) Nothing (\inner -> walker77 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 780; recurses to walker779.
+walker780 :: Core.Term -> Maybe Core.Term
+walker780 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker779 fun) (walker779 arg) (\_ -> walker779 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker779 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker779 body) Nothing (\inner -> walker779 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 781; recurses to walker780.
+walker781 :: Core.Term -> Maybe Core.Term
+walker781 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker780 fun) (walker780 arg) (\_ -> walker780 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker780 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker780 body) Nothing (\inner -> walker780 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 782; recurses to walker781.
+walker782 :: Core.Term -> Maybe Core.Term
+walker782 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker781 fun) (walker781 arg) (\_ -> walker781 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker781 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker781 body) Nothing (\inner -> walker781 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 783; recurses to walker782.
+walker783 :: Core.Term -> Maybe Core.Term
+walker783 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker782 fun) (walker782 arg) (\_ -> walker782 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker782 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker782 body) Nothing (\inner -> walker782 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 784; recurses to walker783.
+walker784 :: Core.Term -> Maybe Core.Term
+walker784 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker783 fun) (walker783 arg) (\_ -> walker783 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker783 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker783 body) Nothing (\inner -> walker783 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 785; recurses to walker784.
+walker785 :: Core.Term -> Maybe Core.Term
+walker785 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker784 fun) (walker784 arg) (\_ -> walker784 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker784 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker784 body) Nothing (\inner -> walker784 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 786; recurses to walker785.
+walker786 :: Core.Term -> Maybe Core.Term
+walker786 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker785 fun) (walker785 arg) (\_ -> walker785 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker785 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker785 body) Nothing (\inner -> walker785 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 787; recurses to walker786.
+walker787 :: Core.Term -> Maybe Core.Term
+walker787 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker786 fun) (walker786 arg) (\_ -> walker786 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker786 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker786 body) Nothing (\inner -> walker786 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 788; recurses to walker787.
+walker788 :: Core.Term -> Maybe Core.Term
+walker788 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker787 fun) (walker787 arg) (\_ -> walker787 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker787 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker787 body) Nothing (\inner -> walker787 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 789; recurses to walker788.
+walker789 :: Core.Term -> Maybe Core.Term
+walker789 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker788 fun) (walker788 arg) (\_ -> walker788 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker788 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker788 body) Nothing (\inner -> walker788 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 79; recurses to walker78.
+walker79 :: Core.Term -> Maybe Core.Term
+walker79 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker78 fun) (walker78 arg) (\_ -> walker78 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker78 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker78 body) Nothing (\inner -> walker78 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 790; recurses to walker789.
+walker790 :: Core.Term -> Maybe Core.Term
+walker790 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker789 fun) (walker789 arg) (\_ -> walker789 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker789 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker789 body) Nothing (\inner -> walker789 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 791; recurses to walker790.
+walker791 :: Core.Term -> Maybe Core.Term
+walker791 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker790 fun) (walker790 arg) (\_ -> walker790 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker790 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker790 body) Nothing (\inner -> walker790 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 792; recurses to walker791.
+walker792 :: Core.Term -> Maybe Core.Term
+walker792 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker791 fun) (walker791 arg) (\_ -> walker791 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker791 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker791 body) Nothing (\inner -> walker791 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 793; recurses to walker792.
+walker793 :: Core.Term -> Maybe Core.Term
+walker793 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker792 fun) (walker792 arg) (\_ -> walker792 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker792 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker792 body) Nothing (\inner -> walker792 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 794; recurses to walker793.
+walker794 :: Core.Term -> Maybe Core.Term
+walker794 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker793 fun) (walker793 arg) (\_ -> walker793 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker793 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker793 body) Nothing (\inner -> walker793 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 795; recurses to walker794.
+walker795 :: Core.Term -> Maybe Core.Term
+walker795 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker794 fun) (walker794 arg) (\_ -> walker794 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker794 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker794 body) Nothing (\inner -> walker794 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 796; recurses to walker795.
+walker796 :: Core.Term -> Maybe Core.Term
+walker796 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker795 fun) (walker795 arg) (\_ -> walker795 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker795 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker795 body) Nothing (\inner -> walker795 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 797; recurses to walker796.
+walker797 :: Core.Term -> Maybe Core.Term
+walker797 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker796 fun) (walker796 arg) (\_ -> walker796 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker796 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker796 body) Nothing (\inner -> walker796 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 798; recurses to walker797.
+walker798 :: Core.Term -> Maybe Core.Term
+walker798 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker797 fun) (walker797 arg) (\_ -> walker797 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker797 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker797 body) Nothing (\inner -> walker797 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 799; recurses to walker798.
+walker799 :: Core.Term -> Maybe Core.Term
+walker799 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker798 fun) (walker798 arg) (\_ -> walker798 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker798 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker798 body) Nothing (\inner -> walker798 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 8; recurses to walker7.
+walker8 :: Core.Term -> Maybe Core.Term
+walker8 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker7 fun) (walker7 arg) (\_ -> walker7 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker7 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker7 body) Nothing (\inner -> walker7 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 80; recurses to walker79.
+walker80 :: Core.Term -> Maybe Core.Term
+walker80 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker79 fun) (walker79 arg) (\_ -> walker79 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker79 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker79 body) Nothing (\inner -> walker79 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 81; recurses to walker80.
+walker81 :: Core.Term -> Maybe Core.Term
+walker81 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker80 fun) (walker80 arg) (\_ -> walker80 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker80 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker80 body) Nothing (\inner -> walker80 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 82; recurses to walker81.
+walker82 :: Core.Term -> Maybe Core.Term
+walker82 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker81 fun) (walker81 arg) (\_ -> walker81 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker81 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker81 body) Nothing (\inner -> walker81 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 83; recurses to walker82.
+walker83 :: Core.Term -> Maybe Core.Term
+walker83 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker82 fun) (walker82 arg) (\_ -> walker82 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker82 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker82 body) Nothing (\inner -> walker82 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 84; recurses to walker83.
+walker84 :: Core.Term -> Maybe Core.Term
+walker84 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker83 fun) (walker83 arg) (\_ -> walker83 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker83 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker83 body) Nothing (\inner -> walker83 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 85; recurses to walker84.
+walker85 :: Core.Term -> Maybe Core.Term
+walker85 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker84 fun) (walker84 arg) (\_ -> walker84 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker84 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker84 body) Nothing (\inner -> walker84 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 86; recurses to walker85.
+walker86 :: Core.Term -> Maybe Core.Term
+walker86 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker85 fun) (walker85 arg) (\_ -> walker85 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker85 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker85 body) Nothing (\inner -> walker85 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 87; recurses to walker86.
+walker87 :: Core.Term -> Maybe Core.Term
+walker87 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker86 fun) (walker86 arg) (\_ -> walker86 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker86 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker86 body) Nothing (\inner -> walker86 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 88; recurses to walker87.
+walker88 :: Core.Term -> Maybe Core.Term
+walker88 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker87 fun) (walker87 arg) (\_ -> walker87 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker87 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker87 body) Nothing (\inner -> walker87 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 89; recurses to walker88.
+walker89 :: Core.Term -> Maybe Core.Term
+walker89 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker88 fun) (walker88 arg) (\_ -> walker88 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker88 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker88 body) Nothing (\inner -> walker88 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 9; recurses to walker8.
+walker9 :: Core.Term -> Maybe Core.Term
+walker9 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker8 fun) (walker8 arg) (\_ -> walker8 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker8 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker8 body) Nothing (\inner -> walker8 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 90; recurses to walker89.
+walker90 :: Core.Term -> Maybe Core.Term
+walker90 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker89 fun) (walker89 arg) (\_ -> walker89 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker89 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker89 body) Nothing (\inner -> walker89 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 91; recurses to walker90.
+walker91 :: Core.Term -> Maybe Core.Term
+walker91 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker90 fun) (walker90 arg) (\_ -> walker90 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker90 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker90 body) Nothing (\inner -> walker90 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 92; recurses to walker91.
+walker92 :: Core.Term -> Maybe Core.Term
+walker92 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker91 fun) (walker91 arg) (\_ -> walker91 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker91 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker91 body) Nothing (\inner -> walker91 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 93; recurses to walker92.
+walker93 :: Core.Term -> Maybe Core.Term
+walker93 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker92 fun) (walker92 arg) (\_ -> walker92 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker92 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker92 body) Nothing (\inner -> walker92 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 94; recurses to walker93.
+walker94 :: Core.Term -> Maybe Core.Term
+walker94 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker93 fun) (walker93 arg) (\_ -> walker93 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker93 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker93 body) Nothing (\inner -> walker93 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 95; recurses to walker94.
+walker95 :: Core.Term -> Maybe Core.Term
+walker95 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker94 fun) (walker94 arg) (\_ -> walker94 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker94 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker94 body) Nothing (\inner -> walker94 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 96; recurses to walker95.
+walker96 :: Core.Term -> Maybe Core.Term
+walker96 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker95 fun) (walker95 arg) (\_ -> walker95 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker95 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker95 body) Nothing (\inner -> walker95 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 97; recurses to walker96.
+walker97 :: Core.Term -> Maybe Core.Term
+walker97 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker96 fun) (walker96 arg) (\_ -> walker96 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker96 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker96 body) Nothing (\inner -> walker96 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 98; recurses to walker97.
+walker98 :: Core.Term -> Maybe Core.Term
+walker98 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker97 fun) (walker97 arg) (\_ -> walker97 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker97 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker97 body) Nothing (\inner -> walker97 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
+-- | Term walker level 99; recurses to walker98.
+walker99 :: Core.Term -> Maybe Core.Term
+walker99 t =
+
+      let stripped = Strip.deannotateTerm t
+      in case stripped of
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in (Optionals.cases (walker98 fun) (walker98 arg) (\_ -> walker98 fun))
+        Core.TermLambda v0 ->
+          let body = Core.lambdaBody v0
+          in (walker98 body)
+        Core.TermLet v0 ->
+          let body = Core.letBody v0
+          in (Optionals.cases (walker98 body) Nothing (\inner -> walker98 inner))
+        Core.TermVariable _ -> Just stripped
+        Core.TermLiteral _ -> Just stripped
+        _ -> Just stripped
diff --git a/src/main/haskell/Hydra/Bench/PolymorphicChain.hs b/src/main/haskell/Hydra/Bench/PolymorphicChain.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Bench/PolymorphicChain.hs
@@ -0,0 +1,2426 @@
+-- Note: this is an automatically generated file. Do not edit.
+-- | Polymorphic-chain inference benchmark. polyWalker_K :: Maybe a -> Maybe a; chains via Optionals.bind, instantiating forall a at each cross-def call site.
+
+module Hydra.Bench.PolymorphicChain where
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+-- | Polymorphic walker level 0; recurses to polyWalker0.
+polyWalker0 :: t0 -> t0
+polyWalker0 m = m
+-- | Polymorphic walker level 1; recurses to polyWalker0.
+polyWalker1 :: Maybe t0 -> Maybe t0
+polyWalker1 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker0 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 10; recurses to polyWalker9.
+polyWalker10 :: Maybe t0 -> Maybe t0
+polyWalker10 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker9 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 100; recurses to polyWalker99.
+polyWalker100 :: Maybe t0 -> Maybe t0
+polyWalker100 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker99 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 101; recurses to polyWalker100.
+polyWalker101 :: Maybe t0 -> Maybe t0
+polyWalker101 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker100 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 102; recurses to polyWalker101.
+polyWalker102 :: Maybe t0 -> Maybe t0
+polyWalker102 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker101 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 103; recurses to polyWalker102.
+polyWalker103 :: Maybe t0 -> Maybe t0
+polyWalker103 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker102 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 104; recurses to polyWalker103.
+polyWalker104 :: Maybe t0 -> Maybe t0
+polyWalker104 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker103 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 105; recurses to polyWalker104.
+polyWalker105 :: Maybe t0 -> Maybe t0
+polyWalker105 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker104 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 106; recurses to polyWalker105.
+polyWalker106 :: Maybe t0 -> Maybe t0
+polyWalker106 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker105 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 107; recurses to polyWalker106.
+polyWalker107 :: Maybe t0 -> Maybe t0
+polyWalker107 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker106 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 108; recurses to polyWalker107.
+polyWalker108 :: Maybe t0 -> Maybe t0
+polyWalker108 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker107 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 109; recurses to polyWalker108.
+polyWalker109 :: Maybe t0 -> Maybe t0
+polyWalker109 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker108 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 11; recurses to polyWalker10.
+polyWalker11 :: Maybe t0 -> Maybe t0
+polyWalker11 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker10 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 110; recurses to polyWalker109.
+polyWalker110 :: Maybe t0 -> Maybe t0
+polyWalker110 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker109 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 111; recurses to polyWalker110.
+polyWalker111 :: Maybe t0 -> Maybe t0
+polyWalker111 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker110 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 112; recurses to polyWalker111.
+polyWalker112 :: Maybe t0 -> Maybe t0
+polyWalker112 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker111 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 113; recurses to polyWalker112.
+polyWalker113 :: Maybe t0 -> Maybe t0
+polyWalker113 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker112 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 114; recurses to polyWalker113.
+polyWalker114 :: Maybe t0 -> Maybe t0
+polyWalker114 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker113 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 115; recurses to polyWalker114.
+polyWalker115 :: Maybe t0 -> Maybe t0
+polyWalker115 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker114 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 116; recurses to polyWalker115.
+polyWalker116 :: Maybe t0 -> Maybe t0
+polyWalker116 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker115 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 117; recurses to polyWalker116.
+polyWalker117 :: Maybe t0 -> Maybe t0
+polyWalker117 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker116 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 118; recurses to polyWalker117.
+polyWalker118 :: Maybe t0 -> Maybe t0
+polyWalker118 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker117 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 119; recurses to polyWalker118.
+polyWalker119 :: Maybe t0 -> Maybe t0
+polyWalker119 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker118 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 12; recurses to polyWalker11.
+polyWalker12 :: Maybe t0 -> Maybe t0
+polyWalker12 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker11 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 120; recurses to polyWalker119.
+polyWalker120 :: Maybe t0 -> Maybe t0
+polyWalker120 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker119 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 121; recurses to polyWalker120.
+polyWalker121 :: Maybe t0 -> Maybe t0
+polyWalker121 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker120 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 122; recurses to polyWalker121.
+polyWalker122 :: Maybe t0 -> Maybe t0
+polyWalker122 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker121 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 123; recurses to polyWalker122.
+polyWalker123 :: Maybe t0 -> Maybe t0
+polyWalker123 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker122 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 124; recurses to polyWalker123.
+polyWalker124 :: Maybe t0 -> Maybe t0
+polyWalker124 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker123 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 125; recurses to polyWalker124.
+polyWalker125 :: Maybe t0 -> Maybe t0
+polyWalker125 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker124 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 126; recurses to polyWalker125.
+polyWalker126 :: Maybe t0 -> Maybe t0
+polyWalker126 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker125 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 127; recurses to polyWalker126.
+polyWalker127 :: Maybe t0 -> Maybe t0
+polyWalker127 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker126 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 128; recurses to polyWalker127.
+polyWalker128 :: Maybe t0 -> Maybe t0
+polyWalker128 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker127 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 129; recurses to polyWalker128.
+polyWalker129 :: Maybe t0 -> Maybe t0
+polyWalker129 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker128 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 13; recurses to polyWalker12.
+polyWalker13 :: Maybe t0 -> Maybe t0
+polyWalker13 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker12 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 130; recurses to polyWalker129.
+polyWalker130 :: Maybe t0 -> Maybe t0
+polyWalker130 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker129 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 131; recurses to polyWalker130.
+polyWalker131 :: Maybe t0 -> Maybe t0
+polyWalker131 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker130 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 132; recurses to polyWalker131.
+polyWalker132 :: Maybe t0 -> Maybe t0
+polyWalker132 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker131 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 133; recurses to polyWalker132.
+polyWalker133 :: Maybe t0 -> Maybe t0
+polyWalker133 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker132 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 134; recurses to polyWalker133.
+polyWalker134 :: Maybe t0 -> Maybe t0
+polyWalker134 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker133 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 135; recurses to polyWalker134.
+polyWalker135 :: Maybe t0 -> Maybe t0
+polyWalker135 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker134 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 136; recurses to polyWalker135.
+polyWalker136 :: Maybe t0 -> Maybe t0
+polyWalker136 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker135 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 137; recurses to polyWalker136.
+polyWalker137 :: Maybe t0 -> Maybe t0
+polyWalker137 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker136 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 138; recurses to polyWalker137.
+polyWalker138 :: Maybe t0 -> Maybe t0
+polyWalker138 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker137 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 139; recurses to polyWalker138.
+polyWalker139 :: Maybe t0 -> Maybe t0
+polyWalker139 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker138 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 14; recurses to polyWalker13.
+polyWalker14 :: Maybe t0 -> Maybe t0
+polyWalker14 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker13 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 140; recurses to polyWalker139.
+polyWalker140 :: Maybe t0 -> Maybe t0
+polyWalker140 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker139 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 141; recurses to polyWalker140.
+polyWalker141 :: Maybe t0 -> Maybe t0
+polyWalker141 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker140 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 142; recurses to polyWalker141.
+polyWalker142 :: Maybe t0 -> Maybe t0
+polyWalker142 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker141 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 143; recurses to polyWalker142.
+polyWalker143 :: Maybe t0 -> Maybe t0
+polyWalker143 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker142 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 144; recurses to polyWalker143.
+polyWalker144 :: Maybe t0 -> Maybe t0
+polyWalker144 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker143 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 145; recurses to polyWalker144.
+polyWalker145 :: Maybe t0 -> Maybe t0
+polyWalker145 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker144 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 146; recurses to polyWalker145.
+polyWalker146 :: Maybe t0 -> Maybe t0
+polyWalker146 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker145 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 147; recurses to polyWalker146.
+polyWalker147 :: Maybe t0 -> Maybe t0
+polyWalker147 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker146 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 148; recurses to polyWalker147.
+polyWalker148 :: Maybe t0 -> Maybe t0
+polyWalker148 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker147 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 149; recurses to polyWalker148.
+polyWalker149 :: Maybe t0 -> Maybe t0
+polyWalker149 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker148 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 15; recurses to polyWalker14.
+polyWalker15 :: Maybe t0 -> Maybe t0
+polyWalker15 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker14 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 150; recurses to polyWalker149.
+polyWalker150 :: Maybe t0 -> Maybe t0
+polyWalker150 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker149 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 151; recurses to polyWalker150.
+polyWalker151 :: Maybe t0 -> Maybe t0
+polyWalker151 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker150 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 152; recurses to polyWalker151.
+polyWalker152 :: Maybe t0 -> Maybe t0
+polyWalker152 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker151 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 153; recurses to polyWalker152.
+polyWalker153 :: Maybe t0 -> Maybe t0
+polyWalker153 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker152 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 154; recurses to polyWalker153.
+polyWalker154 :: Maybe t0 -> Maybe t0
+polyWalker154 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker153 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 155; recurses to polyWalker154.
+polyWalker155 :: Maybe t0 -> Maybe t0
+polyWalker155 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker154 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 156; recurses to polyWalker155.
+polyWalker156 :: Maybe t0 -> Maybe t0
+polyWalker156 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker155 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 157; recurses to polyWalker156.
+polyWalker157 :: Maybe t0 -> Maybe t0
+polyWalker157 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker156 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 158; recurses to polyWalker157.
+polyWalker158 :: Maybe t0 -> Maybe t0
+polyWalker158 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker157 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 159; recurses to polyWalker158.
+polyWalker159 :: Maybe t0 -> Maybe t0
+polyWalker159 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker158 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 16; recurses to polyWalker15.
+polyWalker16 :: Maybe t0 -> Maybe t0
+polyWalker16 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker15 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 160; recurses to polyWalker159.
+polyWalker160 :: Maybe t0 -> Maybe t0
+polyWalker160 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker159 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 161; recurses to polyWalker160.
+polyWalker161 :: Maybe t0 -> Maybe t0
+polyWalker161 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker160 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 162; recurses to polyWalker161.
+polyWalker162 :: Maybe t0 -> Maybe t0
+polyWalker162 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker161 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 163; recurses to polyWalker162.
+polyWalker163 :: Maybe t0 -> Maybe t0
+polyWalker163 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker162 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 164; recurses to polyWalker163.
+polyWalker164 :: Maybe t0 -> Maybe t0
+polyWalker164 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker163 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 165; recurses to polyWalker164.
+polyWalker165 :: Maybe t0 -> Maybe t0
+polyWalker165 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker164 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 166; recurses to polyWalker165.
+polyWalker166 :: Maybe t0 -> Maybe t0
+polyWalker166 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker165 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 167; recurses to polyWalker166.
+polyWalker167 :: Maybe t0 -> Maybe t0
+polyWalker167 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker166 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 168; recurses to polyWalker167.
+polyWalker168 :: Maybe t0 -> Maybe t0
+polyWalker168 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker167 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 169; recurses to polyWalker168.
+polyWalker169 :: Maybe t0 -> Maybe t0
+polyWalker169 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker168 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 17; recurses to polyWalker16.
+polyWalker17 :: Maybe t0 -> Maybe t0
+polyWalker17 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker16 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 170; recurses to polyWalker169.
+polyWalker170 :: Maybe t0 -> Maybe t0
+polyWalker170 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker169 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 171; recurses to polyWalker170.
+polyWalker171 :: Maybe t0 -> Maybe t0
+polyWalker171 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker170 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 172; recurses to polyWalker171.
+polyWalker172 :: Maybe t0 -> Maybe t0
+polyWalker172 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker171 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 173; recurses to polyWalker172.
+polyWalker173 :: Maybe t0 -> Maybe t0
+polyWalker173 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker172 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 174; recurses to polyWalker173.
+polyWalker174 :: Maybe t0 -> Maybe t0
+polyWalker174 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker173 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 175; recurses to polyWalker174.
+polyWalker175 :: Maybe t0 -> Maybe t0
+polyWalker175 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker174 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 176; recurses to polyWalker175.
+polyWalker176 :: Maybe t0 -> Maybe t0
+polyWalker176 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker175 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 177; recurses to polyWalker176.
+polyWalker177 :: Maybe t0 -> Maybe t0
+polyWalker177 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker176 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 178; recurses to polyWalker177.
+polyWalker178 :: Maybe t0 -> Maybe t0
+polyWalker178 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker177 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 179; recurses to polyWalker178.
+polyWalker179 :: Maybe t0 -> Maybe t0
+polyWalker179 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker178 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 18; recurses to polyWalker17.
+polyWalker18 :: Maybe t0 -> Maybe t0
+polyWalker18 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker17 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 180; recurses to polyWalker179.
+polyWalker180 :: Maybe t0 -> Maybe t0
+polyWalker180 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker179 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 181; recurses to polyWalker180.
+polyWalker181 :: Maybe t0 -> Maybe t0
+polyWalker181 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker180 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 182; recurses to polyWalker181.
+polyWalker182 :: Maybe t0 -> Maybe t0
+polyWalker182 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker181 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 183; recurses to polyWalker182.
+polyWalker183 :: Maybe t0 -> Maybe t0
+polyWalker183 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker182 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 184; recurses to polyWalker183.
+polyWalker184 :: Maybe t0 -> Maybe t0
+polyWalker184 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker183 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 185; recurses to polyWalker184.
+polyWalker185 :: Maybe t0 -> Maybe t0
+polyWalker185 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker184 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 186; recurses to polyWalker185.
+polyWalker186 :: Maybe t0 -> Maybe t0
+polyWalker186 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker185 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 187; recurses to polyWalker186.
+polyWalker187 :: Maybe t0 -> Maybe t0
+polyWalker187 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker186 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 188; recurses to polyWalker187.
+polyWalker188 :: Maybe t0 -> Maybe t0
+polyWalker188 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker187 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 189; recurses to polyWalker188.
+polyWalker189 :: Maybe t0 -> Maybe t0
+polyWalker189 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker188 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 19; recurses to polyWalker18.
+polyWalker19 :: Maybe t0 -> Maybe t0
+polyWalker19 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker18 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 190; recurses to polyWalker189.
+polyWalker190 :: Maybe t0 -> Maybe t0
+polyWalker190 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker189 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 191; recurses to polyWalker190.
+polyWalker191 :: Maybe t0 -> Maybe t0
+polyWalker191 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker190 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 192; recurses to polyWalker191.
+polyWalker192 :: Maybe t0 -> Maybe t0
+polyWalker192 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker191 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 193; recurses to polyWalker192.
+polyWalker193 :: Maybe t0 -> Maybe t0
+polyWalker193 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker192 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 194; recurses to polyWalker193.
+polyWalker194 :: Maybe t0 -> Maybe t0
+polyWalker194 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker193 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 195; recurses to polyWalker194.
+polyWalker195 :: Maybe t0 -> Maybe t0
+polyWalker195 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker194 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 196; recurses to polyWalker195.
+polyWalker196 :: Maybe t0 -> Maybe t0
+polyWalker196 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker195 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 197; recurses to polyWalker196.
+polyWalker197 :: Maybe t0 -> Maybe t0
+polyWalker197 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker196 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 198; recurses to polyWalker197.
+polyWalker198 :: Maybe t0 -> Maybe t0
+polyWalker198 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker197 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 199; recurses to polyWalker198.
+polyWalker199 :: Maybe t0 -> Maybe t0
+polyWalker199 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker198 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 2; recurses to polyWalker1.
+polyWalker2 :: Maybe t0 -> Maybe t0
+polyWalker2 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker1 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 20; recurses to polyWalker19.
+polyWalker20 :: Maybe t0 -> Maybe t0
+polyWalker20 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker19 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 200; recurses to polyWalker199.
+polyWalker200 :: Maybe t0 -> Maybe t0
+polyWalker200 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker199 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 201; recurses to polyWalker200.
+polyWalker201 :: Maybe t0 -> Maybe t0
+polyWalker201 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker200 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 202; recurses to polyWalker201.
+polyWalker202 :: Maybe t0 -> Maybe t0
+polyWalker202 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker201 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 203; recurses to polyWalker202.
+polyWalker203 :: Maybe t0 -> Maybe t0
+polyWalker203 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker202 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 204; recurses to polyWalker203.
+polyWalker204 :: Maybe t0 -> Maybe t0
+polyWalker204 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker203 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 205; recurses to polyWalker204.
+polyWalker205 :: Maybe t0 -> Maybe t0
+polyWalker205 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker204 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 206; recurses to polyWalker205.
+polyWalker206 :: Maybe t0 -> Maybe t0
+polyWalker206 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker205 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 207; recurses to polyWalker206.
+polyWalker207 :: Maybe t0 -> Maybe t0
+polyWalker207 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker206 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 208; recurses to polyWalker207.
+polyWalker208 :: Maybe t0 -> Maybe t0
+polyWalker208 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker207 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 209; recurses to polyWalker208.
+polyWalker209 :: Maybe t0 -> Maybe t0
+polyWalker209 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker208 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 21; recurses to polyWalker20.
+polyWalker21 :: Maybe t0 -> Maybe t0
+polyWalker21 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker20 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 210; recurses to polyWalker209.
+polyWalker210 :: Maybe t0 -> Maybe t0
+polyWalker210 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker209 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 211; recurses to polyWalker210.
+polyWalker211 :: Maybe t0 -> Maybe t0
+polyWalker211 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker210 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 212; recurses to polyWalker211.
+polyWalker212 :: Maybe t0 -> Maybe t0
+polyWalker212 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker211 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 213; recurses to polyWalker212.
+polyWalker213 :: Maybe t0 -> Maybe t0
+polyWalker213 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker212 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 214; recurses to polyWalker213.
+polyWalker214 :: Maybe t0 -> Maybe t0
+polyWalker214 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker213 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 215; recurses to polyWalker214.
+polyWalker215 :: Maybe t0 -> Maybe t0
+polyWalker215 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker214 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 216; recurses to polyWalker215.
+polyWalker216 :: Maybe t0 -> Maybe t0
+polyWalker216 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker215 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 217; recurses to polyWalker216.
+polyWalker217 :: Maybe t0 -> Maybe t0
+polyWalker217 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker216 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 218; recurses to polyWalker217.
+polyWalker218 :: Maybe t0 -> Maybe t0
+polyWalker218 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker217 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 219; recurses to polyWalker218.
+polyWalker219 :: Maybe t0 -> Maybe t0
+polyWalker219 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker218 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 22; recurses to polyWalker21.
+polyWalker22 :: Maybe t0 -> Maybe t0
+polyWalker22 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker21 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 220; recurses to polyWalker219.
+polyWalker220 :: Maybe t0 -> Maybe t0
+polyWalker220 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker219 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 221; recurses to polyWalker220.
+polyWalker221 :: Maybe t0 -> Maybe t0
+polyWalker221 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker220 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 222; recurses to polyWalker221.
+polyWalker222 :: Maybe t0 -> Maybe t0
+polyWalker222 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker221 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 223; recurses to polyWalker222.
+polyWalker223 :: Maybe t0 -> Maybe t0
+polyWalker223 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker222 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 224; recurses to polyWalker223.
+polyWalker224 :: Maybe t0 -> Maybe t0
+polyWalker224 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker223 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 225; recurses to polyWalker224.
+polyWalker225 :: Maybe t0 -> Maybe t0
+polyWalker225 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker224 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 226; recurses to polyWalker225.
+polyWalker226 :: Maybe t0 -> Maybe t0
+polyWalker226 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker225 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 227; recurses to polyWalker226.
+polyWalker227 :: Maybe t0 -> Maybe t0
+polyWalker227 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker226 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 228; recurses to polyWalker227.
+polyWalker228 :: Maybe t0 -> Maybe t0
+polyWalker228 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker227 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 229; recurses to polyWalker228.
+polyWalker229 :: Maybe t0 -> Maybe t0
+polyWalker229 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker228 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 23; recurses to polyWalker22.
+polyWalker23 :: Maybe t0 -> Maybe t0
+polyWalker23 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker22 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 230; recurses to polyWalker229.
+polyWalker230 :: Maybe t0 -> Maybe t0
+polyWalker230 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker229 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 231; recurses to polyWalker230.
+polyWalker231 :: Maybe t0 -> Maybe t0
+polyWalker231 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker230 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 232; recurses to polyWalker231.
+polyWalker232 :: Maybe t0 -> Maybe t0
+polyWalker232 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker231 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 233; recurses to polyWalker232.
+polyWalker233 :: Maybe t0 -> Maybe t0
+polyWalker233 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker232 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 234; recurses to polyWalker233.
+polyWalker234 :: Maybe t0 -> Maybe t0
+polyWalker234 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker233 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 235; recurses to polyWalker234.
+polyWalker235 :: Maybe t0 -> Maybe t0
+polyWalker235 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker234 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 236; recurses to polyWalker235.
+polyWalker236 :: Maybe t0 -> Maybe t0
+polyWalker236 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker235 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 237; recurses to polyWalker236.
+polyWalker237 :: Maybe t0 -> Maybe t0
+polyWalker237 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker236 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 238; recurses to polyWalker237.
+polyWalker238 :: Maybe t0 -> Maybe t0
+polyWalker238 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker237 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 239; recurses to polyWalker238.
+polyWalker239 :: Maybe t0 -> Maybe t0
+polyWalker239 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker238 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 24; recurses to polyWalker23.
+polyWalker24 :: Maybe t0 -> Maybe t0
+polyWalker24 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker23 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 240; recurses to polyWalker239.
+polyWalker240 :: Maybe t0 -> Maybe t0
+polyWalker240 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker239 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 241; recurses to polyWalker240.
+polyWalker241 :: Maybe t0 -> Maybe t0
+polyWalker241 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker240 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 242; recurses to polyWalker241.
+polyWalker242 :: Maybe t0 -> Maybe t0
+polyWalker242 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker241 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 243; recurses to polyWalker242.
+polyWalker243 :: Maybe t0 -> Maybe t0
+polyWalker243 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker242 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 244; recurses to polyWalker243.
+polyWalker244 :: Maybe t0 -> Maybe t0
+polyWalker244 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker243 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 245; recurses to polyWalker244.
+polyWalker245 :: Maybe t0 -> Maybe t0
+polyWalker245 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker244 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 246; recurses to polyWalker245.
+polyWalker246 :: Maybe t0 -> Maybe t0
+polyWalker246 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker245 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 247; recurses to polyWalker246.
+polyWalker247 :: Maybe t0 -> Maybe t0
+polyWalker247 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker246 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 248; recurses to polyWalker247.
+polyWalker248 :: Maybe t0 -> Maybe t0
+polyWalker248 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker247 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 249; recurses to polyWalker248.
+polyWalker249 :: Maybe t0 -> Maybe t0
+polyWalker249 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker248 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 25; recurses to polyWalker24.
+polyWalker25 :: Maybe t0 -> Maybe t0
+polyWalker25 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker24 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 250; recurses to polyWalker249.
+polyWalker250 :: Maybe t0 -> Maybe t0
+polyWalker250 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker249 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 251; recurses to polyWalker250.
+polyWalker251 :: Maybe t0 -> Maybe t0
+polyWalker251 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker250 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 252; recurses to polyWalker251.
+polyWalker252 :: Maybe t0 -> Maybe t0
+polyWalker252 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker251 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 253; recurses to polyWalker252.
+polyWalker253 :: Maybe t0 -> Maybe t0
+polyWalker253 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker252 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 254; recurses to polyWalker253.
+polyWalker254 :: Maybe t0 -> Maybe t0
+polyWalker254 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker253 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 255; recurses to polyWalker254.
+polyWalker255 :: Maybe t0 -> Maybe t0
+polyWalker255 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker254 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 256; recurses to polyWalker255.
+polyWalker256 :: Maybe t0 -> Maybe t0
+polyWalker256 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker255 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 257; recurses to polyWalker256.
+polyWalker257 :: Maybe t0 -> Maybe t0
+polyWalker257 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker256 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 258; recurses to polyWalker257.
+polyWalker258 :: Maybe t0 -> Maybe t0
+polyWalker258 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker257 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 259; recurses to polyWalker258.
+polyWalker259 :: Maybe t0 -> Maybe t0
+polyWalker259 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker258 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 26; recurses to polyWalker25.
+polyWalker26 :: Maybe t0 -> Maybe t0
+polyWalker26 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker25 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 260; recurses to polyWalker259.
+polyWalker260 :: Maybe t0 -> Maybe t0
+polyWalker260 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker259 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 261; recurses to polyWalker260.
+polyWalker261 :: Maybe t0 -> Maybe t0
+polyWalker261 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker260 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 262; recurses to polyWalker261.
+polyWalker262 :: Maybe t0 -> Maybe t0
+polyWalker262 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker261 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 263; recurses to polyWalker262.
+polyWalker263 :: Maybe t0 -> Maybe t0
+polyWalker263 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker262 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 264; recurses to polyWalker263.
+polyWalker264 :: Maybe t0 -> Maybe t0
+polyWalker264 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker263 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 265; recurses to polyWalker264.
+polyWalker265 :: Maybe t0 -> Maybe t0
+polyWalker265 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker264 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 266; recurses to polyWalker265.
+polyWalker266 :: Maybe t0 -> Maybe t0
+polyWalker266 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker265 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 267; recurses to polyWalker266.
+polyWalker267 :: Maybe t0 -> Maybe t0
+polyWalker267 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker266 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 268; recurses to polyWalker267.
+polyWalker268 :: Maybe t0 -> Maybe t0
+polyWalker268 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker267 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 269; recurses to polyWalker268.
+polyWalker269 :: Maybe t0 -> Maybe t0
+polyWalker269 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker268 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 27; recurses to polyWalker26.
+polyWalker27 :: Maybe t0 -> Maybe t0
+polyWalker27 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker26 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 270; recurses to polyWalker269.
+polyWalker270 :: Maybe t0 -> Maybe t0
+polyWalker270 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker269 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 271; recurses to polyWalker270.
+polyWalker271 :: Maybe t0 -> Maybe t0
+polyWalker271 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker270 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 272; recurses to polyWalker271.
+polyWalker272 :: Maybe t0 -> Maybe t0
+polyWalker272 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker271 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 273; recurses to polyWalker272.
+polyWalker273 :: Maybe t0 -> Maybe t0
+polyWalker273 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker272 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 274; recurses to polyWalker273.
+polyWalker274 :: Maybe t0 -> Maybe t0
+polyWalker274 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker273 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 275; recurses to polyWalker274.
+polyWalker275 :: Maybe t0 -> Maybe t0
+polyWalker275 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker274 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 276; recurses to polyWalker275.
+polyWalker276 :: Maybe t0 -> Maybe t0
+polyWalker276 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker275 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 277; recurses to polyWalker276.
+polyWalker277 :: Maybe t0 -> Maybe t0
+polyWalker277 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker276 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 278; recurses to polyWalker277.
+polyWalker278 :: Maybe t0 -> Maybe t0
+polyWalker278 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker277 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 279; recurses to polyWalker278.
+polyWalker279 :: Maybe t0 -> Maybe t0
+polyWalker279 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker278 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 28; recurses to polyWalker27.
+polyWalker28 :: Maybe t0 -> Maybe t0
+polyWalker28 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker27 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 280; recurses to polyWalker279.
+polyWalker280 :: Maybe t0 -> Maybe t0
+polyWalker280 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker279 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 281; recurses to polyWalker280.
+polyWalker281 :: Maybe t0 -> Maybe t0
+polyWalker281 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker280 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 282; recurses to polyWalker281.
+polyWalker282 :: Maybe t0 -> Maybe t0
+polyWalker282 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker281 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 283; recurses to polyWalker282.
+polyWalker283 :: Maybe t0 -> Maybe t0
+polyWalker283 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker282 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 284; recurses to polyWalker283.
+polyWalker284 :: Maybe t0 -> Maybe t0
+polyWalker284 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker283 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 285; recurses to polyWalker284.
+polyWalker285 :: Maybe t0 -> Maybe t0
+polyWalker285 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker284 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 286; recurses to polyWalker285.
+polyWalker286 :: Maybe t0 -> Maybe t0
+polyWalker286 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker285 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 287; recurses to polyWalker286.
+polyWalker287 :: Maybe t0 -> Maybe t0
+polyWalker287 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker286 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 288; recurses to polyWalker287.
+polyWalker288 :: Maybe t0 -> Maybe t0
+polyWalker288 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker287 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 289; recurses to polyWalker288.
+polyWalker289 :: Maybe t0 -> Maybe t0
+polyWalker289 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker288 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 29; recurses to polyWalker28.
+polyWalker29 :: Maybe t0 -> Maybe t0
+polyWalker29 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker28 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 290; recurses to polyWalker289.
+polyWalker290 :: Maybe t0 -> Maybe t0
+polyWalker290 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker289 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 291; recurses to polyWalker290.
+polyWalker291 :: Maybe t0 -> Maybe t0
+polyWalker291 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker290 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 292; recurses to polyWalker291.
+polyWalker292 :: Maybe t0 -> Maybe t0
+polyWalker292 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker291 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 293; recurses to polyWalker292.
+polyWalker293 :: Maybe t0 -> Maybe t0
+polyWalker293 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker292 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 294; recurses to polyWalker293.
+polyWalker294 :: Maybe t0 -> Maybe t0
+polyWalker294 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker293 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 295; recurses to polyWalker294.
+polyWalker295 :: Maybe t0 -> Maybe t0
+polyWalker295 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker294 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 296; recurses to polyWalker295.
+polyWalker296 :: Maybe t0 -> Maybe t0
+polyWalker296 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker295 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 297; recurses to polyWalker296.
+polyWalker297 :: Maybe t0 -> Maybe t0
+polyWalker297 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker296 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 298; recurses to polyWalker297.
+polyWalker298 :: Maybe t0 -> Maybe t0
+polyWalker298 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker297 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 299; recurses to polyWalker298.
+polyWalker299 :: Maybe t0 -> Maybe t0
+polyWalker299 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker298 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 3; recurses to polyWalker2.
+polyWalker3 :: Maybe t0 -> Maybe t0
+polyWalker3 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker2 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 30; recurses to polyWalker29.
+polyWalker30 :: Maybe t0 -> Maybe t0
+polyWalker30 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker29 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 300; recurses to polyWalker299.
+polyWalker300 :: Maybe t0 -> Maybe t0
+polyWalker300 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker299 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 301; recurses to polyWalker300.
+polyWalker301 :: Maybe t0 -> Maybe t0
+polyWalker301 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker300 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 302; recurses to polyWalker301.
+polyWalker302 :: Maybe t0 -> Maybe t0
+polyWalker302 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker301 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 303; recurses to polyWalker302.
+polyWalker303 :: Maybe t0 -> Maybe t0
+polyWalker303 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker302 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 304; recurses to polyWalker303.
+polyWalker304 :: Maybe t0 -> Maybe t0
+polyWalker304 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker303 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 305; recurses to polyWalker304.
+polyWalker305 :: Maybe t0 -> Maybe t0
+polyWalker305 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker304 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 306; recurses to polyWalker305.
+polyWalker306 :: Maybe t0 -> Maybe t0
+polyWalker306 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker305 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 307; recurses to polyWalker306.
+polyWalker307 :: Maybe t0 -> Maybe t0
+polyWalker307 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker306 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 308; recurses to polyWalker307.
+polyWalker308 :: Maybe t0 -> Maybe t0
+polyWalker308 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker307 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 309; recurses to polyWalker308.
+polyWalker309 :: Maybe t0 -> Maybe t0
+polyWalker309 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker308 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 31; recurses to polyWalker30.
+polyWalker31 :: Maybe t0 -> Maybe t0
+polyWalker31 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker30 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 310; recurses to polyWalker309.
+polyWalker310 :: Maybe t0 -> Maybe t0
+polyWalker310 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker309 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 311; recurses to polyWalker310.
+polyWalker311 :: Maybe t0 -> Maybe t0
+polyWalker311 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker310 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 312; recurses to polyWalker311.
+polyWalker312 :: Maybe t0 -> Maybe t0
+polyWalker312 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker311 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 313; recurses to polyWalker312.
+polyWalker313 :: Maybe t0 -> Maybe t0
+polyWalker313 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker312 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 314; recurses to polyWalker313.
+polyWalker314 :: Maybe t0 -> Maybe t0
+polyWalker314 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker313 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 315; recurses to polyWalker314.
+polyWalker315 :: Maybe t0 -> Maybe t0
+polyWalker315 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker314 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 316; recurses to polyWalker315.
+polyWalker316 :: Maybe t0 -> Maybe t0
+polyWalker316 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker315 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 317; recurses to polyWalker316.
+polyWalker317 :: Maybe t0 -> Maybe t0
+polyWalker317 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker316 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 318; recurses to polyWalker317.
+polyWalker318 :: Maybe t0 -> Maybe t0
+polyWalker318 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker317 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 319; recurses to polyWalker318.
+polyWalker319 :: Maybe t0 -> Maybe t0
+polyWalker319 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker318 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 32; recurses to polyWalker31.
+polyWalker32 :: Maybe t0 -> Maybe t0
+polyWalker32 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker31 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 320; recurses to polyWalker319.
+polyWalker320 :: Maybe t0 -> Maybe t0
+polyWalker320 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker319 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 321; recurses to polyWalker320.
+polyWalker321 :: Maybe t0 -> Maybe t0
+polyWalker321 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker320 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 322; recurses to polyWalker321.
+polyWalker322 :: Maybe t0 -> Maybe t0
+polyWalker322 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker321 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 323; recurses to polyWalker322.
+polyWalker323 :: Maybe t0 -> Maybe t0
+polyWalker323 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker322 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 324; recurses to polyWalker323.
+polyWalker324 :: Maybe t0 -> Maybe t0
+polyWalker324 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker323 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 325; recurses to polyWalker324.
+polyWalker325 :: Maybe t0 -> Maybe t0
+polyWalker325 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker324 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 326; recurses to polyWalker325.
+polyWalker326 :: Maybe t0 -> Maybe t0
+polyWalker326 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker325 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 327; recurses to polyWalker326.
+polyWalker327 :: Maybe t0 -> Maybe t0
+polyWalker327 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker326 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 328; recurses to polyWalker327.
+polyWalker328 :: Maybe t0 -> Maybe t0
+polyWalker328 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker327 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 329; recurses to polyWalker328.
+polyWalker329 :: Maybe t0 -> Maybe t0
+polyWalker329 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker328 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 33; recurses to polyWalker32.
+polyWalker33 :: Maybe t0 -> Maybe t0
+polyWalker33 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker32 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 330; recurses to polyWalker329.
+polyWalker330 :: Maybe t0 -> Maybe t0
+polyWalker330 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker329 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 331; recurses to polyWalker330.
+polyWalker331 :: Maybe t0 -> Maybe t0
+polyWalker331 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker330 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 332; recurses to polyWalker331.
+polyWalker332 :: Maybe t0 -> Maybe t0
+polyWalker332 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker331 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 333; recurses to polyWalker332.
+polyWalker333 :: Maybe t0 -> Maybe t0
+polyWalker333 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker332 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 334; recurses to polyWalker333.
+polyWalker334 :: Maybe t0 -> Maybe t0
+polyWalker334 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker333 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 335; recurses to polyWalker334.
+polyWalker335 :: Maybe t0 -> Maybe t0
+polyWalker335 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker334 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 336; recurses to polyWalker335.
+polyWalker336 :: Maybe t0 -> Maybe t0
+polyWalker336 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker335 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 337; recurses to polyWalker336.
+polyWalker337 :: Maybe t0 -> Maybe t0
+polyWalker337 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker336 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 338; recurses to polyWalker337.
+polyWalker338 :: Maybe t0 -> Maybe t0
+polyWalker338 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker337 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 339; recurses to polyWalker338.
+polyWalker339 :: Maybe t0 -> Maybe t0
+polyWalker339 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker338 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 34; recurses to polyWalker33.
+polyWalker34 :: Maybe t0 -> Maybe t0
+polyWalker34 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker33 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 340; recurses to polyWalker339.
+polyWalker340 :: Maybe t0 -> Maybe t0
+polyWalker340 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker339 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 341; recurses to polyWalker340.
+polyWalker341 :: Maybe t0 -> Maybe t0
+polyWalker341 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker340 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 342; recurses to polyWalker341.
+polyWalker342 :: Maybe t0 -> Maybe t0
+polyWalker342 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker341 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 343; recurses to polyWalker342.
+polyWalker343 :: Maybe t0 -> Maybe t0
+polyWalker343 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker342 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 344; recurses to polyWalker343.
+polyWalker344 :: Maybe t0 -> Maybe t0
+polyWalker344 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker343 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 345; recurses to polyWalker344.
+polyWalker345 :: Maybe t0 -> Maybe t0
+polyWalker345 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker344 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 346; recurses to polyWalker345.
+polyWalker346 :: Maybe t0 -> Maybe t0
+polyWalker346 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker345 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 347; recurses to polyWalker346.
+polyWalker347 :: Maybe t0 -> Maybe t0
+polyWalker347 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker346 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 348; recurses to polyWalker347.
+polyWalker348 :: Maybe t0 -> Maybe t0
+polyWalker348 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker347 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 349; recurses to polyWalker348.
+polyWalker349 :: Maybe t0 -> Maybe t0
+polyWalker349 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker348 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 35; recurses to polyWalker34.
+polyWalker35 :: Maybe t0 -> Maybe t0
+polyWalker35 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker34 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 350; recurses to polyWalker349.
+polyWalker350 :: Maybe t0 -> Maybe t0
+polyWalker350 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker349 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 351; recurses to polyWalker350.
+polyWalker351 :: Maybe t0 -> Maybe t0
+polyWalker351 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker350 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 352; recurses to polyWalker351.
+polyWalker352 :: Maybe t0 -> Maybe t0
+polyWalker352 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker351 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 353; recurses to polyWalker352.
+polyWalker353 :: Maybe t0 -> Maybe t0
+polyWalker353 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker352 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 354; recurses to polyWalker353.
+polyWalker354 :: Maybe t0 -> Maybe t0
+polyWalker354 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker353 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 355; recurses to polyWalker354.
+polyWalker355 :: Maybe t0 -> Maybe t0
+polyWalker355 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker354 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 356; recurses to polyWalker355.
+polyWalker356 :: Maybe t0 -> Maybe t0
+polyWalker356 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker355 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 357; recurses to polyWalker356.
+polyWalker357 :: Maybe t0 -> Maybe t0
+polyWalker357 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker356 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 358; recurses to polyWalker357.
+polyWalker358 :: Maybe t0 -> Maybe t0
+polyWalker358 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker357 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 359; recurses to polyWalker358.
+polyWalker359 :: Maybe t0 -> Maybe t0
+polyWalker359 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker358 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 36; recurses to polyWalker35.
+polyWalker36 :: Maybe t0 -> Maybe t0
+polyWalker36 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker35 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 360; recurses to polyWalker359.
+polyWalker360 :: Maybe t0 -> Maybe t0
+polyWalker360 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker359 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 361; recurses to polyWalker360.
+polyWalker361 :: Maybe t0 -> Maybe t0
+polyWalker361 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker360 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 362; recurses to polyWalker361.
+polyWalker362 :: Maybe t0 -> Maybe t0
+polyWalker362 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker361 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 363; recurses to polyWalker362.
+polyWalker363 :: Maybe t0 -> Maybe t0
+polyWalker363 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker362 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 364; recurses to polyWalker363.
+polyWalker364 :: Maybe t0 -> Maybe t0
+polyWalker364 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker363 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 365; recurses to polyWalker364.
+polyWalker365 :: Maybe t0 -> Maybe t0
+polyWalker365 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker364 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 366; recurses to polyWalker365.
+polyWalker366 :: Maybe t0 -> Maybe t0
+polyWalker366 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker365 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 367; recurses to polyWalker366.
+polyWalker367 :: Maybe t0 -> Maybe t0
+polyWalker367 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker366 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 368; recurses to polyWalker367.
+polyWalker368 :: Maybe t0 -> Maybe t0
+polyWalker368 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker367 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 369; recurses to polyWalker368.
+polyWalker369 :: Maybe t0 -> Maybe t0
+polyWalker369 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker368 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 37; recurses to polyWalker36.
+polyWalker37 :: Maybe t0 -> Maybe t0
+polyWalker37 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker36 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 370; recurses to polyWalker369.
+polyWalker370 :: Maybe t0 -> Maybe t0
+polyWalker370 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker369 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 371; recurses to polyWalker370.
+polyWalker371 :: Maybe t0 -> Maybe t0
+polyWalker371 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker370 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 372; recurses to polyWalker371.
+polyWalker372 :: Maybe t0 -> Maybe t0
+polyWalker372 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker371 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 373; recurses to polyWalker372.
+polyWalker373 :: Maybe t0 -> Maybe t0
+polyWalker373 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker372 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 374; recurses to polyWalker373.
+polyWalker374 :: Maybe t0 -> Maybe t0
+polyWalker374 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker373 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 375; recurses to polyWalker374.
+polyWalker375 :: Maybe t0 -> Maybe t0
+polyWalker375 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker374 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 376; recurses to polyWalker375.
+polyWalker376 :: Maybe t0 -> Maybe t0
+polyWalker376 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker375 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 377; recurses to polyWalker376.
+polyWalker377 :: Maybe t0 -> Maybe t0
+polyWalker377 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker376 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 378; recurses to polyWalker377.
+polyWalker378 :: Maybe t0 -> Maybe t0
+polyWalker378 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker377 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 379; recurses to polyWalker378.
+polyWalker379 :: Maybe t0 -> Maybe t0
+polyWalker379 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker378 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 38; recurses to polyWalker37.
+polyWalker38 :: Maybe t0 -> Maybe t0
+polyWalker38 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker37 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 380; recurses to polyWalker379.
+polyWalker380 :: Maybe t0 -> Maybe t0
+polyWalker380 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker379 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 381; recurses to polyWalker380.
+polyWalker381 :: Maybe t0 -> Maybe t0
+polyWalker381 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker380 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 382; recurses to polyWalker381.
+polyWalker382 :: Maybe t0 -> Maybe t0
+polyWalker382 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker381 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 383; recurses to polyWalker382.
+polyWalker383 :: Maybe t0 -> Maybe t0
+polyWalker383 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker382 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 384; recurses to polyWalker383.
+polyWalker384 :: Maybe t0 -> Maybe t0
+polyWalker384 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker383 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 385; recurses to polyWalker384.
+polyWalker385 :: Maybe t0 -> Maybe t0
+polyWalker385 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker384 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 386; recurses to polyWalker385.
+polyWalker386 :: Maybe t0 -> Maybe t0
+polyWalker386 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker385 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 387; recurses to polyWalker386.
+polyWalker387 :: Maybe t0 -> Maybe t0
+polyWalker387 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker386 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 388; recurses to polyWalker387.
+polyWalker388 :: Maybe t0 -> Maybe t0
+polyWalker388 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker387 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 389; recurses to polyWalker388.
+polyWalker389 :: Maybe t0 -> Maybe t0
+polyWalker389 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker388 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 39; recurses to polyWalker38.
+polyWalker39 :: Maybe t0 -> Maybe t0
+polyWalker39 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker38 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 390; recurses to polyWalker389.
+polyWalker390 :: Maybe t0 -> Maybe t0
+polyWalker390 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker389 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 391; recurses to polyWalker390.
+polyWalker391 :: Maybe t0 -> Maybe t0
+polyWalker391 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker390 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 392; recurses to polyWalker391.
+polyWalker392 :: Maybe t0 -> Maybe t0
+polyWalker392 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker391 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 393; recurses to polyWalker392.
+polyWalker393 :: Maybe t0 -> Maybe t0
+polyWalker393 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker392 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 394; recurses to polyWalker393.
+polyWalker394 :: Maybe t0 -> Maybe t0
+polyWalker394 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker393 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 395; recurses to polyWalker394.
+polyWalker395 :: Maybe t0 -> Maybe t0
+polyWalker395 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker394 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 396; recurses to polyWalker395.
+polyWalker396 :: Maybe t0 -> Maybe t0
+polyWalker396 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker395 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 397; recurses to polyWalker396.
+polyWalker397 :: Maybe t0 -> Maybe t0
+polyWalker397 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker396 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 398; recurses to polyWalker397.
+polyWalker398 :: Maybe t0 -> Maybe t0
+polyWalker398 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker397 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 399; recurses to polyWalker398.
+polyWalker399 :: Maybe t0 -> Maybe t0
+polyWalker399 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker398 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 4; recurses to polyWalker3.
+polyWalker4 :: Maybe t0 -> Maybe t0
+polyWalker4 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker3 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 40; recurses to polyWalker39.
+polyWalker40 :: Maybe t0 -> Maybe t0
+polyWalker40 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker39 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 41; recurses to polyWalker40.
+polyWalker41 :: Maybe t0 -> Maybe t0
+polyWalker41 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker40 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 42; recurses to polyWalker41.
+polyWalker42 :: Maybe t0 -> Maybe t0
+polyWalker42 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker41 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 43; recurses to polyWalker42.
+polyWalker43 :: Maybe t0 -> Maybe t0
+polyWalker43 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker42 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 44; recurses to polyWalker43.
+polyWalker44 :: Maybe t0 -> Maybe t0
+polyWalker44 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker43 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 45; recurses to polyWalker44.
+polyWalker45 :: Maybe t0 -> Maybe t0
+polyWalker45 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker44 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 46; recurses to polyWalker45.
+polyWalker46 :: Maybe t0 -> Maybe t0
+polyWalker46 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker45 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 47; recurses to polyWalker46.
+polyWalker47 :: Maybe t0 -> Maybe t0
+polyWalker47 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker46 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 48; recurses to polyWalker47.
+polyWalker48 :: Maybe t0 -> Maybe t0
+polyWalker48 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker47 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 49; recurses to polyWalker48.
+polyWalker49 :: Maybe t0 -> Maybe t0
+polyWalker49 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker48 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 5; recurses to polyWalker4.
+polyWalker5 :: Maybe t0 -> Maybe t0
+polyWalker5 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker4 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 50; recurses to polyWalker49.
+polyWalker50 :: Maybe t0 -> Maybe t0
+polyWalker50 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker49 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 51; recurses to polyWalker50.
+polyWalker51 :: Maybe t0 -> Maybe t0
+polyWalker51 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker50 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 52; recurses to polyWalker51.
+polyWalker52 :: Maybe t0 -> Maybe t0
+polyWalker52 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker51 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 53; recurses to polyWalker52.
+polyWalker53 :: Maybe t0 -> Maybe t0
+polyWalker53 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker52 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 54; recurses to polyWalker53.
+polyWalker54 :: Maybe t0 -> Maybe t0
+polyWalker54 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker53 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 55; recurses to polyWalker54.
+polyWalker55 :: Maybe t0 -> Maybe t0
+polyWalker55 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker54 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 56; recurses to polyWalker55.
+polyWalker56 :: Maybe t0 -> Maybe t0
+polyWalker56 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker55 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 57; recurses to polyWalker56.
+polyWalker57 :: Maybe t0 -> Maybe t0
+polyWalker57 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker56 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 58; recurses to polyWalker57.
+polyWalker58 :: Maybe t0 -> Maybe t0
+polyWalker58 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker57 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 59; recurses to polyWalker58.
+polyWalker59 :: Maybe t0 -> Maybe t0
+polyWalker59 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker58 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 6; recurses to polyWalker5.
+polyWalker6 :: Maybe t0 -> Maybe t0
+polyWalker6 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker5 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 60; recurses to polyWalker59.
+polyWalker60 :: Maybe t0 -> Maybe t0
+polyWalker60 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker59 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 61; recurses to polyWalker60.
+polyWalker61 :: Maybe t0 -> Maybe t0
+polyWalker61 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker60 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 62; recurses to polyWalker61.
+polyWalker62 :: Maybe t0 -> Maybe t0
+polyWalker62 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker61 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 63; recurses to polyWalker62.
+polyWalker63 :: Maybe t0 -> Maybe t0
+polyWalker63 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker62 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 64; recurses to polyWalker63.
+polyWalker64 :: Maybe t0 -> Maybe t0
+polyWalker64 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker63 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 65; recurses to polyWalker64.
+polyWalker65 :: Maybe t0 -> Maybe t0
+polyWalker65 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker64 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 66; recurses to polyWalker65.
+polyWalker66 :: Maybe t0 -> Maybe t0
+polyWalker66 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker65 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 67; recurses to polyWalker66.
+polyWalker67 :: Maybe t0 -> Maybe t0
+polyWalker67 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker66 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 68; recurses to polyWalker67.
+polyWalker68 :: Maybe t0 -> Maybe t0
+polyWalker68 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker67 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 69; recurses to polyWalker68.
+polyWalker69 :: Maybe t0 -> Maybe t0
+polyWalker69 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker68 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 7; recurses to polyWalker6.
+polyWalker7 :: Maybe t0 -> Maybe t0
+polyWalker7 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker6 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 70; recurses to polyWalker69.
+polyWalker70 :: Maybe t0 -> Maybe t0
+polyWalker70 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker69 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 71; recurses to polyWalker70.
+polyWalker71 :: Maybe t0 -> Maybe t0
+polyWalker71 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker70 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 72; recurses to polyWalker71.
+polyWalker72 :: Maybe t0 -> Maybe t0
+polyWalker72 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker71 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 73; recurses to polyWalker72.
+polyWalker73 :: Maybe t0 -> Maybe t0
+polyWalker73 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker72 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 74; recurses to polyWalker73.
+polyWalker74 :: Maybe t0 -> Maybe t0
+polyWalker74 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker73 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 75; recurses to polyWalker74.
+polyWalker75 :: Maybe t0 -> Maybe t0
+polyWalker75 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker74 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 76; recurses to polyWalker75.
+polyWalker76 :: Maybe t0 -> Maybe t0
+polyWalker76 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker75 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 77; recurses to polyWalker76.
+polyWalker77 :: Maybe t0 -> Maybe t0
+polyWalker77 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker76 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 78; recurses to polyWalker77.
+polyWalker78 :: Maybe t0 -> Maybe t0
+polyWalker78 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker77 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 79; recurses to polyWalker78.
+polyWalker79 :: Maybe t0 -> Maybe t0
+polyWalker79 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker78 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 8; recurses to polyWalker7.
+polyWalker8 :: Maybe t0 -> Maybe t0
+polyWalker8 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker7 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 80; recurses to polyWalker79.
+polyWalker80 :: Maybe t0 -> Maybe t0
+polyWalker80 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker79 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 81; recurses to polyWalker80.
+polyWalker81 :: Maybe t0 -> Maybe t0
+polyWalker81 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker80 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 82; recurses to polyWalker81.
+polyWalker82 :: Maybe t0 -> Maybe t0
+polyWalker82 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker81 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 83; recurses to polyWalker82.
+polyWalker83 :: Maybe t0 -> Maybe t0
+polyWalker83 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker82 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 84; recurses to polyWalker83.
+polyWalker84 :: Maybe t0 -> Maybe t0
+polyWalker84 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker83 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 85; recurses to polyWalker84.
+polyWalker85 :: Maybe t0 -> Maybe t0
+polyWalker85 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker84 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 86; recurses to polyWalker85.
+polyWalker86 :: Maybe t0 -> Maybe t0
+polyWalker86 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker85 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 87; recurses to polyWalker86.
+polyWalker87 :: Maybe t0 -> Maybe t0
+polyWalker87 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker86 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 88; recurses to polyWalker87.
+polyWalker88 :: Maybe t0 -> Maybe t0
+polyWalker88 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker87 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 89; recurses to polyWalker88.
+polyWalker89 :: Maybe t0 -> Maybe t0
+polyWalker89 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker88 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 9; recurses to polyWalker8.
+polyWalker9 :: Maybe t0 -> Maybe t0
+polyWalker9 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker8 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 90; recurses to polyWalker89.
+polyWalker90 :: Maybe t0 -> Maybe t0
+polyWalker90 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker89 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 91; recurses to polyWalker90.
+polyWalker91 :: Maybe t0 -> Maybe t0
+polyWalker91 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker90 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 92; recurses to polyWalker91.
+polyWalker92 :: Maybe t0 -> Maybe t0
+polyWalker92 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker91 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 93; recurses to polyWalker92.
+polyWalker93 :: Maybe t0 -> Maybe t0
+polyWalker93 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker92 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 94; recurses to polyWalker93.
+polyWalker94 :: Maybe t0 -> Maybe t0
+polyWalker94 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker93 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 95; recurses to polyWalker94.
+polyWalker95 :: Maybe t0 -> Maybe t0
+polyWalker95 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker94 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 96; recurses to polyWalker95.
+polyWalker96 :: Maybe t0 -> Maybe t0
+polyWalker96 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker95 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 97; recurses to polyWalker96.
+polyWalker97 :: Maybe t0 -> Maybe t0
+polyWalker97 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker96 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 98; recurses to polyWalker97.
+polyWalker98 :: Maybe t0 -> Maybe t0
+polyWalker98 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker97 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))
+-- | Polymorphic walker level 99; recurses to polyWalker98.
+polyWalker99 :: Maybe t0 -> Maybe t0
+polyWalker99 m =
+
+      let stepped = Optionals.bind m (\v -> polyWalker98 (Just v))
+      in (Optionals.cases stepped Nothing (\w -> Just w))