diff --git a/CHANGES.md b/CHANGES.md
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,4 +1,157 @@
-##### Clafer Version 0.4.5 released on March 13, 2017
+##### Clafer Version 0.5.8, Nov 15, 2026
+
+* Builds with GHC 9.12.4 (Stackage nightly-2026-11-11) and still with GHC 9.6.7. The lexer is generated with alex 3.5: the lexer generated in 2018 did not compile with GHC 9.12 (`Int#` instead of `Int16#`).
+* No longer depends on `data-stringmap`, which is not maintained and does not build with GHC 9.6 or later from Hackage: the maps of UIDs are `Data.Map` maps. The outputs are the same (the positive test models and the case studies), and compiling is as fast.
+* No longer depends on `json-builder`, which is not maintained and does not build from Hackage with GHC 8.4 or later: the `.cfr-map` and `.cfr-scope` files are written with `aeson`'s encoding, field by field in the same order. The files of the positive test models (Alloy and Choco modes) are the same.
+* Depends only on the packages it uses: `cond`, `executable-path`, `mtl-compat`, `parsec` and `transformers-compat` are no longer dependencies of the library, and `HUnit`, `QuickCheck` and `lens-aeson` no longer of the test suites.
+* The initializer `:=` is the initial value of a reference ([kbak/clafer-semantics#164](https://github.com/kbak/clafer-semantics/issues/164), `doc/initial-value.md`, errata T14). It compiled to an assertion in every output ([#116](https://github.com/gsdlab/clafer/issues/116)), so `x -> integer := 10` with `[ x = 5 ]` had instances and a counterexample; it is a hard constraint now, and has no instance there.
+  * In a static model, `:=` is the same as `=`: `[ some x => x.dref = 10 ]` in the parent's context. The outputs are the same as with `=`, and an initializer does not make a model temporal.
+  * In a temporal model, every lifetime of `x` starts with the value, which may change afterwards: `[ initially this.dref = 10 ]` in the context of `x`. The value is resolved in the parent's context, where it is written: `this` is the parent, and a name `y` is the sibling `y` of `x` even if `x` has a child `y`.
+  * A set initializer, e.g., `xs -> integer * := 1, 2`, stays in the parent's context: `[ initially (some xs => xs.dref = 1, 2) ]`. The instances created later are not initialized.
+  * A `final` or `finalref` reference keeps the value it starts with: with `finalref x -> integer := y`, `x` takes the value of `y` when its lifetime starts, and keeps it when `y` changes, which `= y` would contradict.
+  * Inheritance is pure strengthening (reading A in kbak/clafer-semantics#164): a subclafer's own `:=` or `=` is added to the inherited initializer and never replaces it, so `= 2` under `:= 2` fixes the value in every state, and `:= 3` has no instance. The reverse, `:=` under an inherited `=`, does not redefine it either: both hold, so an equal value repeats the inherited one and another value leaves the subclafer without instances. The compiler warns that the `:=` does not redefine the inherited `=` (also through a reference to a constant, e.g., `abstract K -> 5`), without claiming that it is redundant ([#124](https://github.com/gsdlab/clafer/issues/124); test case `InitializerUnderInheritedConstant`).
+  * New test models: `initialValueStatic` (the same instances as with `=` in claferIG and chocosolver), `tmp_initialValue01` (an optional `level` created later), `tmp_initialValue02` (a mandatory `x` whose value changes), `tmp_initialValue03` (a parent that is replaced), `tmp_initialValue04` (`finalref` and `final`, also with a value that changes), `tmp_initialValue05` (set initializers), `tmp_initialValue06` (the name resolution and an abstract clafer), and the test case `InitialValue`.
+* `let v = e in body` compiles ([#114](https://github.com/gsdlab/clafer/issues/114)): it is `body` with `e` for `v`. It crashed the compiler in every mode ("pattern expressions should have been transformed previously"). The bound expression may be any expression above `in`, e.g., `let s = a + b in s > 2` or `let w = A.v in w = 3`; it could only be a name. A quantifier or a `let` in `body` that binds `v` again hides it, and one that binds a name used in `e` is renamed (`x_1`), so that `e` keeps its meaning. New test model: `let_binding`.
+* A path as a super, e.g., `h : Person.Head`, extends the abstract clafer it names. It was not resolved: with a constraint on `h`, the compiler crashed ("Maybe.fromJust: Nothing"), and without one, the super was dropped (`sig h` instead of `sig h extends Person__Head` in Alloy), since 0.4.3 at least.
+  * The first name of the path is a clafer, the nearest enclosing one with the name or else the only one, preferring a top-level one. Each next name is a child of the previous clafer: its own, or, if it has none with the name, the nearest inherited one. So under `Ella : Person`, `Ella.Head` is `Person.Head`, unless Ella redefines Head, e.g., with `abstract Head : Head`: then it is Ella's Head, which extends Person's.
+  * A path disambiguates between abstract clafers with the same name, e.g., `Dog.Head` and `Person.Head`. A path to a concrete clafer is an error, as a name of a concrete clafer is ("No superclafer found").
+  * A plain name of a super is the nearest abstract clafer with the name among the children of the parent and the children it inherits: `h : Head` next to `abstract Head : Head` extends that sibling. It extended the inherited Head.
+  * In the HTML output, each name of the path links to its clafer; the last one linked to a name that was not a UID, e.g., `#Head` instead of `#Person__Head`.
+  * New test model `path_super`, and the negative test model `extends_concrete_clafer_by_path`.
+* An ambiguous name of a super, e.g., `x : T` with `A.T` and `B.T`, is an error that the name is not unique, with the paths of the candidates (`A.A__T`, `B.B__T`), as for a reference ([#115](https://github.com/gsdlab/clafer/issues/115)). It was reported as a duplicate definition, with the UIDs. Two supers with the same name in the same namespace are still a duplicate definition. New negative test model `ambiguous_super_name` and the test case `AmbiguousSuperName`.
+* A group cardinality interval at the start of a line, e.g., `2..3 b` after a clafer `a` without a cardinality, is the group cardinality of `b` ([#117](https://github.com/gsdlab/clafer/issues/117)). It silently became the cardinality of `a`, and the children of `b` became mandatory. The layout resolver separates the lines of siblings, so an element ends at the end of its line: an expression of a clafer, e.g., a reference target, no longer continues on the next line at the same indentation (`a ->` and then `b` on the next line was `a -> b`; it is a syntax error now). New test model `group_cardinality_after_clafer` and the test case `GroupCardinalityOnNextLine`.
+* The Choco output declares the supers of all clafers, then the references, the reference of a super before those of its subclafers, and then the constraints ([#118](https://github.com/gsdlab/clafer/issues/118)). The statements were in the order of the model, so chocosolver refused a reference refined to a clafer declared further down, e.g., `E1 : Edge -> N2` under `abstract Edge -> Node ?` before `N2 : Node` ("E1 cannot refine reference from abstract Node to N2"), as in the wiki model `graphReachability`. New test model: `refine_reference_to_later_clafer`.
+* The graph outputs quote the labels of the reference edges (`-m graph`) and the node names (`-m cvlGraph`), so that dot draws a model with a clafer named after a keyword of DOT, e.g., `abstract Edge -> Node ?` in `abstract Node`; dot refused `label=Edge` ("syntax error near 'Edge'"). New test model: `graph_dot_keywords`.
+* Set references (`->`): the targets of the instances of a clafer under one parent are distinct also when the clafer inherits the reference, e.g., `r : Ref 2` under `abstract Ref -> Target`, in temporal models ([#121](https://github.com/gsdlab/clafer/issues/121)); only a reference of the clafer's own was checked, so the two instances of `r` could point to the same target. Instances of different clafers may share a target, also when they inherit the reference from the same top-level abstract clafer, which has no parent ([#125](https://github.com/gsdlab/clafer/issues/125)): `a : Ref` and `b : Ref` may both be 1 under `abstract Ref -> integer`. The static Alloy output made the targets of all the instances of a top-level abstract clafer distinct, unlike the temporal output and chocosolver; a static model in which instances of different subclafers share a target has more instances now, e.g., `set_reference_keys` has 2 instead of none. The test models whose Alloy output loses the key keep their instances, since each of their abstract clafers has a single instance. Bag references (`->>`) have no key. New test models: `set_reference_keys`, `tmp_set_reference_keys`, and the test case `SetReferenceKeys`.
+* Temporal models: a reference that refines an inherited one, e.g., `r : Ref -> integer`, is the same reference as the inherited one ([#120](https://github.com/gsdlab/clafer/issues/120)): an instance of `r` has one target, whether seen through `r` or `Ref`. The temporal output let them differ, so `[ all q : Ref | q.dref = 2 ]` and `[ G (r.dref = 1) ]` had traces; the static output already had the constraint. New test model `tmp_refined_reference`, and the test case `RefinedReferenceTemporal`.
+* Temporal models: an instance has a reference only while it exists, as it has children only while it exists (reading A of [kbak/clafer-semantics#168](https://github.com/kbak/clafer-semantics/issues/168), [#122](https://github.com/gsdlab/clafer/issues/122)). So an obligation on the value of an instance requires the instance to exist: `[ initially X (this.dref = 7) ]` fails if `x` disappears in the next state. The reference of an absent instance was unconstrained, so a value that no trace shows met the obligation, and claferIG gave traces that differed only in such values. A rule such as `[ all v : integer | (this = v --> this = v + 1) ]` keeps its clafer alive now. New test model `tmp_absent_reference`, and the test case `AbsentReference`.
+* Temporal models: the value of an initializer keeps the temporal context of the parent, where it is written ([#123](https://github.com/gsdlab/clafer/issues/123)): in `x -> integer := if X (some flag) then 1 else 2`, the obligation `X (some flag)` lasts as long as the parent of the parent of `x`, and `initially` and `finally` in a value refer to the lifetime of the parent. The names in the value were resolved in the parent's context, but its temporal operators were bounded as in the context of `x`. The explicit form shows such a value in the context of `x`. New test model `tmp_initialValue07`, and the test case `InitialValueTemporalContext`.
+
+##### Clafer Version 0.5.7, Nov 8, 2026
+
+* The UID of a clafer is its least-partially-qualified name, with `__` between the names: `size` if no other clafer is named `size`, `x__size` for the `size` in `x` otherwise, and `root__size` for a top-level `size` that is the end of another clafer's path. It was `c0_size`, `c1_size`, ..., numbered in the order of the model, for every clafer, so a UID changed when a clafer with the same name was added before it, and tools cut the prefix off to show the name (which also cut `abc_def` to `def`). The UIDs are the names in all outputs: the Alloy signatures, the Choco model, the explicit model, the JSON IR, the HTML anchors and the scope files. An apostrophe is `_prime` (`a'` is `a_prime`; it was `c0_a__prime__`), and a UID that would be the same as one before it in the model gets `__2`, `__3`, ... (e.g., `a_prime` next to `a'`, or a copy of an inherited clafer with `-i`).
+  * A UID is also the least-partially-qualified name in the `.cfr-map` and the scope files; the fully qualified name is `root__x__size` (it was `::x::size`). A lookup by name takes a UID or a qualified name with `__`, and the older form with `::`.
+  * The outputs write the UIDs in the form their language allows: the Alloy output renames a clafer whose UID is an Alloy keyword (e.g., `sig`), a function of `util/integer` (e.g., `max`) or a name the generators write (e.g., `show`), or whose relation or reference names clash with another clafer's (`r_x` next to `x`), to the first free `sig_1`, `sig_2`, ...; the variables of the Choco output are `$` and the UID (`$x__size = $x.addChild("x__size")`), and those of the locals of quantifiers `$_` and the name, so that a clafer named, e.g., `join` or `global`, or a local with the name of a clafer, does not replace them.
+  * A name with `__` is a warning in a full model, with its position, since `__` separates the names of a UID; in an explicit model (`-f`, `--explicit`) it is expected.
+  * The HTML and graph outputs take the names of the clafers from the model, not from their UIDs.
+* A reference to a clafer that extends the referencing abstract clafer, e.g., `abstract Person -> Bob` with `Bob : Person`, no longer makes the compiler loop with `-f` (since the names became the UIDs with `-f` in this release): the walk through the supers and references ends at a clafer that is already on its path.
+* A reference to a union of targets with a nested clafer, e.g., `u -> Hub.p ++ fast`, has valid Alloy output: the field is declared over the union of their signatures (`p + fast`), as it is for one target. Alloy refused the path in the declaration (`The name "@r_p" cannot be found`), in static and temporal models; the explicit model keeps the targets as a constraint (`[this.dref in (Hub.p ++ fast)]`).
+* Temporal models: the obligations of a constraint (`X`, `F`, `G`, `U`) last while the parent of its context instance exists, not only while the context instance exists ([#107](https://github.com/gsdlab/clafer/issues/107)). A transition nested in its source state, e.g., `[ req=down --> movingDown ]` in the state `movingUp`, as in the power window of Juodisius et al. (2019), takes the machine to `movingDown`; it only forced leaving `movingUp`. The pending obligations of nested states still lapse when their enclosing state is left, and `[ X no this ]` makes an instance last one step. For a top-level clafer, whose parent is the root, they last for the whole trace.
+* The transition of a clafer, e.g., `on --> off`, is a constraint of the clafer, with the same meaning as before. For `-->>`, the source lasts until the target holds, while its parent exists.
+* Temporal models: a negated obligation lapses with the parent too ([#110](https://github.com/gsdlab/clafer/issues/110)). The negations are pushed inside the temporal operators first, with the dualities of LTL: `!F a` is `G !a`, `!X a` is `X !a`, and `!(a U b)` is `!b W (!a && !b)`. So `[ !(F error) ]` lets the parent disappear, like `[ G !error ]`; it required the parent to exist forever. A formula and its negation may both hold, on a lifetime that ends before their obligations are due. This also applies to the negated parts of the patterns, e.g., `F r` in the scope `between q and r` holds only when `r` occurs while the parent exists. `finally` is an operator of its own, with the same meaning.
+* Temporal models: a top-level constraint or assertion holds for `root`, without a variable that Alloy warns about (`all self_ : root | ...` left `self_` unused: "This variable is unused", which claferIG shows as a relevance warning, e.g., for the CoffeeMachine example). No temporal test model or example has an Alloy warning; before, 27 of the test models had one.
+* The CheatSheet and the comments of the temporal generator say that a scope bounds the instances of a clafer over the whole trace, not in each state, and that an instance keeps its parent across its absences; a second way out of a state is a constraint in the state, which has the lifetime of the state's own transition ([#111](https://github.com/gsdlab/clafer/issues/111)). New test models: a transition in a final machine and in a replaceable one, negated obligations, the identities in a scope, and the parent of a reappearing instance.
+* The names after an explicit `dref` are the children of the reference's target ([#108](https://github.com/gsdlab/clafer/issues/108)): `this.dref.speed`, `dref.speed` and `all t : this.dref | t.speed = 3` compile, and mean the target's `speed`, also when the reference clafer has a child `speed` of its own. They did not compile, since at least 0.5.2 ("Cannot deref from type", or an ambiguous name when the target was a reference too): the name was resolved through the reference a second time.
+* A comparison (`=`, `!=`, `in`, `not in`), an intersection (`**`) or a difference (`--`) of two navigations to reference clafers is of their targets ([#87](https://github.com/gsdlab/clafer/issues/87)): `this.a = parent.b.a` is `this.a.dref = parent.b.a.dref`. It compared the instances of `a`, which are never the same under different parents, so such a constraint made a model inconsistent, or held trivially when negated. An operand that is `this`, a variable or ends with `dref` is taken as written, e.g., `this in b.a` in `sel -> b.a`.
+* `parent` of an instance of a top-level clafer is the synthetic `root` ([#112](https://github.com/gsdlab/clafer/issues/112)): in a top-level clafer `b`, `parent.a` and `this.parent.a` are `root.a`, i.e., `a`. They compiled to Alloy that refers to the missing relation `@r_c0_b`, and failed in chocosolver with "Cannot join c0_b . parent". The root has no instance in the outputs: `some root`, `one root` and `lone root` hold, `no root` does not, `#root` is 1, and other uses of `root` as a value are refused; `[ some root ]` compiled to an undefined `root`. The parent of a set of instances, e.g., `a.parent` for `a ?`, is the root when an instance exists and empty otherwise: `some a.parent` is `some a`, `#a.parent` is 1 or 0, and `a.parent.c` is `c` when `a` exists.
+  * New negative test models for the refused uses: `root_in_union`, `variable_over_root`, `root_as_child`, `compare_root_with_clafer` and `parent_of_optional_top_level`. `doc/root.md` records why the static outputs have no root while the temporal output has a root signature, and what either alternative would cost.
+* In a top-level abstract clafer whose subclafers are at the top level and nested, a constraint on the parent of `this` is split on `this`: for the instances of the top-level subclafers, the parent is the root, and for each nested subclafer, the parent of its instances. With `abstract Feat [ some parent ]`, `f1 : Feat` and `g` with `f2 : Feat`, `f1` had no parent in Alloy, so the model had no instances, and chocosolver refused the model; both give the instance now. The parent of a variable of such a clafer is refused. Temporal models already gave the top-level subclafers the root as their parent.
+* `root.a` in a temporal model is the top-level clafer `a`; it was the relation from the root to `a`, e.g., in `root.a.x = 2`.
+* Temporal models: `final`, `finalref` and `finaltarget` on a clafer that inherits its reference fix the reference ([#109](https://github.com/gsdlab/clafer/issues/109)), e.g., `final motor : engine` under `abstract engine -> Engine`. They fixed only a reference that the clafer declares, so the motor could point to another engine later in the trace; `finalref` and `finaltarget` without a reference of the clafer's own were ignored. A reference modifier after another modifier, e.g., `initial final x -> T`, is no longer ignored either.
+* Temporal models: `finaltarget` fixes the set of targets of a clafer's instances while their parent exists, so the instances may change and swap their targets, but a new instance points to one of the targets; `finalref` fixes the reference of each instance while it exists, and `final` both ([kbak/clafer-semantics#127](https://github.com/kbak/clafer-semantics/issues/127)). `finaltarget` fixed the reference of each instance, as `finalref` does. A clafer keeps all its reference modifiers, so `finalref finaltarget x -> T` means both, in either order; only the first one was kept.
+* Temporal models: `s must follow p between q and r` requires an `s` before `r` for each `p` up to `r`; it checked only a `p` in the state of `q`, since the brackets of Dwyer's formula were misplaced. `s must precede p after q` starts at the first `q`; Dwyer's formula could start at a later `q`, so q, p, q, s held. At the top level, where a pattern holds in every state, each `q` starts a scope ([kbak/clafer-semantics#127](https://github.com/kbak/clafer-semantics/issues/127)).
+* The test model `tmp_TLSHandshakeProtocol_distributed.cfr`, the TLS 1.2 handshake, has traces; it had none since 0.5.0. It mixed tabs and spaces, so most states were nested in the wrong clafers; its versions were compared as instances (#87), and a client and a server agree on a version when they have one in common; the transitions that leave a phase are constraints of the channel, and a phase is left only from its last states; a fatal alert ends the connection; and the server's Finished message no longer contradicts its phase. Its scenarios: a full handshake of 10 states (12 with client authentication), no data before the server's Finished, and a fatal alert when the versions do not overlap.
+* Temporal models: a name that resolves through a reference, e.g., `this.speed` in `l -> Port`, compiles to valid Alloy; it joined the target with the set of all existing `speed`s.
+* `make test` fails when a test suite fails, or when an output of the positive test models differs from its regression, has no regression, or a regression has no output; the outputs become the new regressions, to be reviewed and committed. It passed regardless, so the regressions of 0.5.6 were outdated.
+  * `make test` compiles and validates the positive test models in parallel, one model per core (`make test JOBS=4` for 4 at a time); the messages of each model are printed together. The positive suite takes 75 seconds on 32 threads.
+  * The outputs are compared with their regressions exactly; whitespace and blank lines were ignored, so, e.g., a change of the spacing in the explicit models passed unnoticed.
+  * `make test` also fails when a positive test model does not compile or one of its outputs does not validate, and names those models after compiling all of them. It printed the errors and passed, e.g., with the Alloy output of `explicit_dref_navigation`, which Alloy refused.
+  * `clafer -v` exits with 1 when a tool rejects an output: Alloy, chocosolver, dot, or clafer itself, for the explicit model, which must compile to itself. A counterexample is not a failure. It printed the error and exited with 0, and did not check the explicit model.
+* Temporal models: `parent` of an instance of a top-level abstract clafer, and its constraints' obligations, use the parents of its subclafers' instances; `parent` was empty for the instances of a nested subclafer, so `[ some this.parent ]` in `abstract Port` excluded them.
+* An abstract clafer that no concrete clafer inherits from, directly or through other abstract clafers, and the clafers in it have the scope 0. With `--keep-unused`, as in claferIG, Alloy gave such a clafer atoms of its own, which its constraints were translated for, and which references could point to; e.g., the power window with three abstract variants of its controller took 223 s for its first trace, and takes 2 s. `emptyAbstracts` in `ScopeAnalysis` gives these clafers.
+* The simple scope analysis no longer adds the instances of a clafer that has none, e.g., such an abstract clafer, to the scope of its super: every subclafer added at least 1. The scopes of the supers are smaller, e.g., `WaitingLine` 2 instead of 4 and `participants` 4 instead of 8 in the tutorial, and the `Element` of the UML class diagram model 4 instead of 25.
+* Temporal models leave out the abstract clafers that the optimizer removed, as static models do; the temporal generator took the clafers of the model before the optimization.
+* The unused JavaCC grammar `src/Language/Clafer/Front/Clafer.jj` is removed. It dated from 2012, was never part of the compiler, and did not follow the syntax since 0.4; the grammar is `src/clafer.cf`.
+* Scope files (`.cfr-scope`, claferIG's `loadScopes`): entries other than `{"lpqName": name, "scope": n}`, e.g., chocosolver's `{"int": [-8, 7]}` or `{"defaultScope": 1}`, are skipped; they stopped claferIG with an error. A name may also be a clafer's UID, e.g., `Component__Cfeatures`, as chocosolver writes them.
+* Explicit models: a model with everything written out, e.g., as chocosolver's `AstPrinter` prints one, is a Clafer model that compiles to itself with `clafer -f -k -l --ss=none`: all 131 positive test models with a Choco output, printed that way, compile to the same model and give the same instances.
+  * `-f` (`--skip-resolver`) means that the names of the clafers are their UIDs: they are not renamed, and they are still resolved and checked, so a misspelled name is an error. It was ignored for models with inheritance, which were renamed (`c0_A` became `c0_c0_A`), and without inheritance it skipped the name resolution and its checks. A name that cannot be a UID, of several clafers or with an apostrophe, is an error with `-f`; `-f` was ignored then too.
+  * The Choco output of a nested assertion is quantified over the instances of its clafer, e.g., `assert [ age >= 0 ]` in `abstract P` is `all this_ : P | this_.age >= 0`. It was an assertion over `this` without a context, which chocosolver's validation (`-v`) refused with a type error.
+  * A navigation from an intersection or a difference of sets, e.g., `(this ** g.f2).parent`, resolves: from the right operand of `**` and the left of `--`, which contain the set. The split constraints of #112 are of this form.
+  * `-m clafer` prints the explicit model of a static model: what chocosolver solves, with every name a UID, every card and group card (inherited ones too), `this`, `parent` and `dref` written out, nested assertions quantified over their clafer, nesting in braces, and the objectives and assertions at the end. With `--meta-data`, its scope file (`model.des.cfr-scope`) has every scope: each clafer's by its UID, the default scope and the ranges of integers, strings and decimals. It printed the desugared model, which was not Clafer: elements ran together on one line (`assert [...]assert [...]abstract ...`). The JavaScript and the explicit model are printed from one walk over the model, so they are the same model: for all 132 positive test models with a Choco output, the explicit model is the one chocosolver prints for the `.js` (for 18, up to the order of abstract and concrete siblings that the solver does not see), with the same scope file, it compiles to itself, and chocosolver gives the same instances for it as for the `.js`. Models with reals have no explicit model yet: `-m clafer` prints nothing for them (it printed their desugared model).
+  * `-m clafer` prints the explicit model of a temporal model too, e.g., in ClaferIDE for the temporal CoffeeMachine example, where it showed nothing. It has the temporal modifiers (`initial`, `final`, `finalref`, `finaltarget`) on the clafers, the temporal operators (`F`, `G`, `X`, `U`, `W`, `initially`, `finally`), the patterns and the transitions as the formulas they stand for (`a --> b` in `a` is `[((#this) >= 1) => (X ((#this.parent.b) >= 1))]`), and the trace length among the options (`//# OPTIONS --explicit --tl=10`). chocosolver does not solve it, and Alloy does: all 64 temporal positive test models compile to themselves, and with the original's scopes, Alloy finds as many traces (up to 20) and counterexamples for the explicit model as for the original.
+  * A nested assertion is quantified over the instances of its clafer by the path from its top-level clafer, as clafer resolves the name, e.g., `all this_ : machine . ctx | ...` for an assertion in `ctx` in `machine`: with `ctx`, the explicit model did not compile to itself.
+  * `--explicit` marks an explicit model: a shorthand for `-f -k -l --ss=none`. An explicit model starts with `//# OPTIONS --explicit`, which `-m clafer` writes, so it needs no options and any file name; chocosolver reads such a model with its own parser, without the compiler.
+* `--meta-data` no longer hangs on a model with a single clafer: the search for its least-partially-qualified name did not end.
+* `noclafer`, the empty set: no instance of any clafer ([kbak/clafer-semantics#134](https://github.com/kbak/clafer-semantics/issues/134)). Its type is below every clafer type, so `a ++ noclafer` and `if c then a else noclafer` have the type of `a`. Like `root`, it is a reserved name and never declared. The root handling of #112 writes it for a navigation from the parent of an optional top-level clafer (`if some extra then a else noclafer`), where it wrote `a -- a`. Alloy gets `none`; Choco gets an empty constant of the clafer of the set beside it, e.g., `constant($a)`, or of the model's first clafer. A navigation from it, e.g., `noclafer.d` or `noclafer.parent`, is `noclafer`, whatever it navigates to, with a warning. The test model `noclafer.cfr` asserts its laws, which Alloy 6.2 and chocosolver both check.
+* A comparison, a difference or an intersection of an expression with itself, e.g., `[ a = a ]` or `noclafer = noclafer`, is a warning, with its position and what it means (always true, always false, always empty, or the expression itself); it was an error, so a correct model did not compile. The warnings are printed with the statistics, like those about large scopes.
+* `clafer` as a value: the set of all instances of all clafers, the root excluded, i.e., the union of the clafers with no super clafer, nested ones by their paths (`Thing ++ c ++ c.d`). Static models only; temporal models refuse it.
+
+##### Clafer Version 0.5.6, Nov 1, 2026
+
+* The Alloy outputs have the nested assertions too, for each instance of their clafer, and name the assertions by their line and column (`assertAt_3_5`), so that a line can have several assertions. Nested assertions were ignored, silently in temporal models.
+* Temporal models (behavioural Clafer) compile to the temporal logic of Alloy 6: mutable relations (`var`) and the operators `always`, `after`, `eventually` and `until`. The temporal generator encoded traces explicitly for Alloy 4.2, which had no temporal operators, and its output did not compile with Alloy 6. The Alloy Analyzer 6.2 finds the traces of small temporal models and checks their assertions in seconds.
+* The semantics of temporal models follows Juodisius et al., *Clafer: Lightweight Modeling of Structure, Behaviour, and Variability* (2019), sections 5 and 6: `a --> b` is `a => X b`, `a -->> b` is `a => (this && a) U b`, and a guard strengthens the precondition (`a -[g]-> b` is `a && g => X b`). It differs from the paper in these points:
+  * An instance may disappear and reappear, which cyclic state machines need in the lasso traces of Alloy.
+  * The temporal obligations of a constraint (`X`, `F`, `G`, `U`) hold while its context instance exists; a constraint placed higher in the hierarchy, or at the top level, lasts longer.
+  * The transition of a clafer, e.g., `on --> off`, is a constraint of its parent, so the transition of a nested state disappears when its enclosing state is left.
+  * A chain of transitions is a sequence: `a --> b --> c` is `a => X (b && X c)` (it was `a => X (b => X c)`), e.g., the scenario `[ initially (green --> yellow --> red) ]`. Its first state is a condition, so a scenario states it when the model does not force it.
+* Unsat cores of temporal models: the constraints and the cardinalities of the children are facts of their own in the Alloy output, for which Alloy gives the unsat core, so that claferIG can show the constraints that contradict each other; Alloy gives the core of the temporal formulas of a signature fact for the whole fact. The constraint of a clafer transition spans the clafer and its transition, e.g., `green --> yellow`.
+* Enumerations are final in dynamic models: their literals do not change over time ([#92](https://github.com/gsdlab/clafer/issues/92)). In static models, they are not final, so that they do not make the model dynamic.
+* The parent of a quantified variable, e.g., `[ all b1 : b | b1.parent = a ]`, is the parent of its clafer; it was taken from the context of the constraint, and the compiler failed with "Prelude.head: empty list".
+* Partially qualified names match whole names: `yellow` matched `yellow_on` and `yellow_off` too, so it was ambiguous, and its least-partially-qualified name, e.g., in a `.cfr-scope` file, was qualified more than needed (`normal::yellow`).
+* HTML and graph outputs: expressions are shown with the parentheses that the grammar requires, e.g., `[ (1 + 2) * 3 = 9 ]` and `X (a || b)`, which were shown as `[ 1 + 2 * 3 = 9 ]` and `X a || b`. `X` was shown as `F`, and the guarded arrows `-[g]->` and `-[g]->>` as `-[g]-->` and `-[g]-->>`.
+* The temporal test models are fixed according to the paper and the above changes, the traffic light models are split into one file per model and its scenarios, which import it, and the test suite compiles each model with the models it imports.
+
+##### Clafer Version 0.5.5, Oct 27, 2026
+
+* Decimals: a primitive type `decimal` of numbers with a fixed number of fractional digits, the decimal scale of the model, for the Choco backend (chocosolver 0.5.5). A plain decimal literal, e.g., `19.99`, is a decimal (it was a `real`); the scale is the most fractional digits of the literals, as written, or `--decimal-digits`. `decimal * decimal` and divisions with a decimal round half away from zero; a division of integers stays an integer division. Integers are decimals, decimals and doubles are reals, and a decimal and a double do not mix. `real` and `double` stay unsupported by the backends, and the Alloy backend does not support decimals. In the Choco output: `refTo(Decimal)`, `decimal("19.99")` and `decimalScale(2)`.
+* `clafer-mode.el` highlights `decimal` as a type.
+* Scopes: a reference with an unbounded multiplicity (`-> Feature *`) gets the scope of its target per parent, as intended; the target's scope was read before it was computed, so it could be 1 or a partial sum of the target's subclafers. Models whose references needed more targets than that had no instances, e.g., ClaferCaseStudies' `AADL_Complete.cfr`.
+* Scopes: in the Alloy and Choco modes, the statistics warn about such references whose scope is above 100 and suggest an upper bound, e.g., `Warning: model.cfr:16:5: the scope of Cfeatures -> Feature 0..* is 1672, since Cfeatures may point to all 76 Feature in each of its parents. If fewer suffice, give it an upper bound, e.g., Cfeatures -> Feature 0..10, to make the instance generation faster.`
+
+##### Clafer Version 0.5.4, Oct 25, 2026
+
+* Models in several files: `--import=FILE`, in `//# OPTIONS` or on the command line, compiles the model together with the imported files, transitively, each file once and before the files importing it ([#100](https://github.com/gsdlab/clafer/issues/100)). The options of all files are combined. The model and its imports can be URLs; an import is relative to the importing file's folder or URL.
+* Errors give their position as `file.cfr:line:column`, also in a model of one file (`Parse failed at model.cfr:3:5...`, previously `line 3 column 5`), and in a model with imports, the file in which they are. A model read from the standard input is `<stdin>`.
+* A syntax error's message no longer repeats the line (`syntax error before ? }`), which in a model with imports was a line of the complete model; the position is given with the error.
+* Restricted imports, for models that may come from anyone (e.g., in a web tool): `--import-root=DIR` allows local imports only inside the given folders, after resolving `..` and symbolic links; `--public-imports` allows URL imports only from public addresses (not loopback, private, or link-local ones), checked when connecting, also after a redirect; `--import-base=URL` resolves the imports of a model whose text was read from a URL. These options, `-v`, and `--tooldir` can only be given on the command line, not in `//# OPTIONS`. Downloads are limited to 16 MB.
+* An imported file must be a `.cfr` file: a URL's path must end with `.cfr`, also after a redirect, and a URL served as HTML, JSON or XML is refused, so that a model cannot read other files or web pages.
+* Models read from URLs: `https://` works (it was read as a local file name), outputs are named after the URL's last segment, in the current directory, and `ftp://` is no longer supported. The compiler uses http-client instead of the HTTP package.
+* `//# OPTIONS`: an unknown option or a malformed directive is an error; the whole directive used to be ignored silently. When compiling with the `clafer` executable, a directive with `-m` or with an option's short or custom name (e.g., `-k`, `--check-afm`, `--nl`) was ignored entirely, and `--tl` and `--tooldir` in the directive were overridden by the defaults.
+* Clafer names with apostrophes (`same'`) work with Alloy and Choco: an apostrophe is not allowed in their identifiers (in Alloy 6, it is the next-state operator), so it becomes `__prime__` in the clafer's UID (`c0_same__prime__`); the name keeps it. Such models are not counted as able to skip the name resolver.
+* `opt` makes the children optional again, as in the language's definition: a child without a multiplicity is optional (`0..1`) under a keyword group (`xor`, `or`, `mux`, `opt`). Since 0.3.3, the default depended only on the interval, and `opt`, being `0..*` like no group at all, made its children mandatory. Only the keywords set `_isKeyword` in the IR, no longer the ranges `0..n`. Children of other ranges are optional and children of no group or `0..*` are mandatory, as before.
+* A group cardinality whose lower bound the children cannot reach is a compile error, e.g., `xor` or `or` over no children, or `3..*` over two optional children. The children include the inherited ones, and the group cardinality may be inherited or redefined (`2..2 myGroup : SuperGroup`). Such groups were not constrained in the Alloy and Choco output. An abstract clafer's group is not checked, since its subclafers may add children.
+* Layout: comments do not count in the indentation. A line which starts with a comment (`/*history*/ xor on`) is indented as if the comment was not there, at the column where the comment starts. The first clafer after the comment was nested by its own column, which put the following lines at wrong levels.
+* JSON output: the IR has the source positions of the clafers (`_cinPos`) and expressions (`_inPos`), which were always `null`: `{"file": "model.cfr", "start": {"line": 2, "column": 3}, "end": {"line": 2, "column": 6}}`, the file and the position in it, with lines and columns from 1 and an exclusive end. A tab advances the column to the next multiple of 8, plus 1, as in the compiler's error messages. The span of a clafer with children ends one or two columns after its last token, at the closing brace that the layout resolver inserts. Desugared expressions without a position in the model are still `null`.
+* HTML output: comments are escaped and shown as written (`--add-comments`); markup in a comment was rendered, and `--` in a `//#` comment could end the generated HTML comment early.
+* HTML output: each file of the model starts with its name (`<div class="file">model.cfr</div>`), also a model of one file, and the comments before a `//# FRAGMENT` directive are shown before it. The HTML shown for a model with errors gives their positions as `file.cfr:line:column`, and an error message with quotes no longer ends the tooltip.
+* [Release](https://github.com/gsdlab/clafer/pull/101)
+
+##### Clafer Version 0.5.3, Oct 15, 2026
+
+Minor release: compiler fixes found with larger example models, the integer range of the Choco output, and a reorganized test suite.
+
+* Type checker: no crash on arithmetic over `max`/`min` of a union, or on if/then/else over unions and dereferenced references.
+* Alloy output: `a - b` was generated as `-a`; `parent` of a top-level abstract clafer is the union of the parent relations of its subclafers ([#84](https://github.com/gsdlab/clafer/issues/84)).
+* References: `-> 1` lost the constant ([#89](https://github.com/gsdlab/clafer/issues/89)); redefinition of an inherited abstract clafer ([#86](https://github.com/gsdlab/clafer/issues/86)); Choco references to set expressions were dropped; unused abstract clafers named by a reference or a constraint are kept.
+* Implicit `.dref` in unions (`BobPicks ++ 3`, `others ++ p1`); `sum` and `product` over a union.
+* Inside a reference clafer, an ancestor (`Machine`, `parent`) is the enclosing instance, and the children of the target resolve through the reference.
+* Scope inference covers the lower bound of group cardinalities.
+* Sibling clafers on one line (`b : B A 3`) are a parse error.
+* Alloy 6.2.0 (`alloy6.2.0.jar`, Java 17+) replaces Alloy 4.2; the generated Alloy models are unchanged. `--validate` runs all Alloy commands headlessly (`alloy exec`) and no longer opens the Alloy visualizer.
+* New options `--minint` and `--maxint` (also in `//# OPTIONS`) set the integer range of the Choco output.
+* The example models and regression tests run in the `model-tests` suite (flag `model-tests`, off by default) and are not part of the package.
+* [Release](https://github.com/gsdlab/clafer/pull/99)
+
+##### Clafer Version 0.5.2 released on Oct 9, 2026
+
+Minor release, Haskell compatibility (GHC 9.6.7 and lts-22.44).
+
+* [Release](https://github.com/gsdlab/clafer/pull/98)
+
+##### Clafer Version 0.5.1 released on Sep 12, 2023
+
+Minor release, latest Haskell compatibility (GHC 9.4.6 and LTS-21.11).
+
+* [Release](https://github.com/gsdlab/clafer/pull/95)
+
+##### Clafer Version 0.5.0 released on Jan 31, 2018
+
+This major release adds behavioral modeling capability to Clafer.
+
+* [Release](https://github.com/gsdlab/clafer/pull/94)
+
+##### Clafer Version 0.4.5 released on Mar 13, 2017
 
 * [Release](https://github.com/gsdlab/clafer/pull/91)
 
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,5 @@
-Copyright 2012-2017 Generative Software Development Lab <http://gsd.uwaterloo.ca>
+Copyright 2012-2019 Generative Software Development Lab <http://gsd.uwaterloo.ca>
+Copyright 2019-2023 Intelligent Systems Development Lab <https://uwaterloo.ca/wise-lab/>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
diff --git a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
@@ -4,9 +4,12 @@
 EXE := .exe
 endif
 
+ALLOY_JAR := alloy6.2.0.jar
+ALLOY_URL := https://github.com/AlloyTools/org.alloytools.alloy/releases/download/v6.2.0/org.alloytools.alloy.dist.jar
+
 all: build
 
-build: alloy4.2.jar
+build: $(ALLOY_JAR)
 	stack build
 
 install:
@@ -14,7 +17,7 @@
 	cp -f README.md $(to)/clafer-README.md
 	cp -f LICENSE $(to)/
 	cp -f CHANGES.md $(to)/clafer-CHANGES.md
-	cp -f alloy4.2.jar $(to)
+	cp -f $(ALLOY_JAR) $(to)
 	cp -f ecore2clafer.jar $(to)
 	cp `stack path --local-install-root`/bin/clafer$(EXE) $(to)
 
@@ -24,14 +27,17 @@
 
 # Just like "init" but with enabled profiler
 # this will reinstall everything with profiling support, build clafer, and copy it to .
-prof: alloy4.2.jar
-	stack build --executable-profiling --library-profiling --ghc-options="-prof -fprof-auto -auto-all -caf-all -rtsopts -osuf p_o"
+prof: $(ALLOY_JAR)
+	stack build --executable-profiling --library-profiling --ghc-options="-auto-all -caf-all -rtsopts -osuf p_o"
 
 .PHONY: test
-test:
+# Build first, so that the regression tests use the current compiler.
+test: build
 	cp `stack path --local-install-root`/bin/clafer$(EXE) .
-	stack test 2>/dev/null || :    # supress error message and exit code if fail
-	$(MAKE) -C $(TEST_DIR) test
+	@# run the regression tests also when the test suites fail, and fail if either fails
+	stack test; suites=$$?; \
+	$(MAKE) -C $(TEST_DIR) test; regressions=$$?; \
+	test $$suites -eq 0 -a $$regressions -eq 0
 
 generateAlloyJSHTMLDot:
 	$(MAKE) -C $(TEST_DIR) generateAlloyJSHTMLDot
@@ -66,21 +72,6 @@
 	codex update
 	mv codex.tags tags
 
-WGET_COMMAND := wget
-ifeq ($(OS),Windows_NT)
-	ifeq ($(shell which wget), which: wget: unkown command)
-		pacman -S make wget
-	endif
-else
-	UNAME_S := $(shell uname -s)
-	ifeq ($(UNAME_S),Darwin)
-		WGET_COMMAND := curl -O
-	endif
-endif
-
-alloy4.2.jar:
-	@if test ! -f "alloy4.2.jar"; then \
-		echo "[WARNING] Missing alloy4.2.jar. Downloading...";  \
-		$(WGET_COMMAND) http://alloy.mit.edu/alloy/downloads/alloy4.2_2015-02-22.jar; \
-		mv alloy4.2_2015-02-22.jar alloy4.2.jar; \
-	fi
+$(ALLOY_JAR):
+	@echo "[WARNING] Missing $(ALLOY_JAR). Downloading..."
+	curl -fsSL -o $(ALLOY_JAR) $(ALLOY_URL)
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -3,19 +3,19 @@
 
 # Clafer, the language
 
-##### v0.4.5
-
+##### v0.5.8
 
-[Clafer](http://clafer.org) is a general-purpose lightweight structural modeling language developed by
+[Clafer](http://clafer.org) is a general-purpose lightweight structural and behavioral modeling language developed by
 [GSD Lab](http://gsd.uwaterloo.ca/), [University of Waterloo](http://uwaterloo.ca), and
 [MODELS](http://www.itu.dk/research/models/) group at [IT University of Copenhagen](http://www.itu.dk/).
-Clafer can be used for modeling of static hierarchical structures but has no support for modeling the change of the structures over time (behavior).
+Clafer can be used for modeling of static hierarchical structures and for modeling the change of the structures over time (behavior). Clafer allows for naturally expressing variability in both the structure and behavior.
 The main goal of Clafer is to make modeling more accessible to a wider range of users and domains.
 
 There are many possible applications of Clafer; however, three are prominent:
 
 1. *Product-Line Architecture Modeling* - aims at representing and managing commonality and variability of assets in product lines and creating and verifying product configurations.
 Clafer naturally supports multi-staged configuration.
+By applying modeling patterns, Clafer can be used for feature modeling, architecture modeling (e.g., by applying EAST-ADL), and behavior modeling (e.g., hierarchical state transition systems). All these aspects naturally include variability.
 
 2. *Multi-Objective Product Optimization* - aims at finding a set of products in a given product line that are optimal with respect to a set of objectives.
 Clafer multi-objective optimizer generates a Pareto front of optimal product configurations.
@@ -23,11 +23,17 @@
 3. *Domain Modeling* - aims at improving the understanding of the problem domain in the early stages of software development and determining the requirements with fewer defects.
 This is also known as *Concept Modeling* or *Ontology Modeling*.
 
+4. *Concept Behavior Modeling* - aims at eliciting how a structure of a concept evolved
+over time and checking properties of possible behaviors.
+
 May applications actually combine the three. For example, see [Technical Report: Case Studies on E/E Architectures for Power Window and Central Door Locks Systems](http://www.clafer.org/2016/06/technical-report-case-studies-on-ee.html).
 
+For examples of behavior modeling, see [Behavioral Modeling](https://wiselab.uwaterloo.ca/modelwiki/#behavioral-modeling) section on the wiki.
+Behavior models compile to the temporal logic of Alloy 6: [ClaferIG](https://github.com/gsdlab/claferIG) generates their traces and checks their assertions. The Choco backend supports only static models.
+
 ### Resources
 
-* [Learning Clafer](http://t3-necsis.cs.uwaterloo.ca:8091/#learning-clafer)
+* [Learning Clafer](https://wiselab.uwaterloo.ca/modelwiki/#learning-clafer)
 * [Cheat Sheet](doc/CheatSheet.md)
 * [Syntax Documentation](doc/clafer.pdf)
 * [Grammar](src/clafer.cf)
@@ -50,7 +56,7 @@
 
 ## Contributors
 
-* [Michał Antkiewicz](http://gsd.uwaterloo.ca/mantkiew), Main developer.
+* [Michał Antkiewicz](https://uwaterloo.ca/wise-lab/profiles/michal-antkiewicz), Main developer.
 * [Kacper Bak](http://gsd.uwaterloo.ca/kbak), Original developer.
 * [Jimmy Liang](http://gsd.uwaterloo.ca/jliang), Developer.
 * Luke Michael Brown, co-op student May-Aug 2013. Many improvements.
@@ -63,58 +69,65 @@
 
 ### Dependencies for running
 
-Regardless of the installation method, the following are
-
-Optional:
+The compiler itself needs nothing else. The following are optional, regardless of the installation method:
 
-* [Java Platform (JDK)](http://www.oracle.com/technetwork/java/javase/downloads/index.html) v8+, 64bit
-  * only needed for running Alloy validation
-  * 32bit on Windows
-* [Alloy4.2](http://alloy.mit.edu/alloy/download.html)
-  * only needed for Alloy output validation
+* [Java](https://adoptium.net) 17 or newer, 64-bit (a runtime is enough)
+  * only needed for validating the outputs (`--validate`) and for `--ecore2clafer`
+* [Alloy 6.2.0](https://github.com/AlloyTools/org.alloytools.alloy/releases/tag/v6.2.0) (`alloy6.2.0.jar`)
+  * only needed for validating the Alloy output (`--validate`)
+* `chocosolver.jar` from [chocosolver](https://github.com/gsdlab/chocosolver)
+  * only needed for validating the Choco output (`--validate`)
+* `ecore2clafer.jar` (in this repository)
+  * only needed for `--ecore2clafer`
 * [GraphViz](http://graphviz.org/)
-  * the program `dot` is needed only in the `html` mode for SVG graph generation
+  * the program `dot` is needed only in the `html` mode for SVG graph generation, and for validating the graph outputs
 
+`--validate` and `--ecore2clafer` look for the jars in the tools directory: the current directory, or the one given with `--tooldir=<directory>`.
+
 ### Installation from binaries
 
-Binary distributions of the release 0.4.5 of Clafer Tools for Windows, Mac, and Linux,
+Binary distributions of Clafer Tools (`clafer`, `claferIG`, and `chocosolver` with the jars they need; Linux x86-64 for the recent releases)
 can be downloaded from
-[Clafer Tools - Binary Distributions](http://gsd.uwaterloo.ca/clafer-tools-binary-distributions).
+[Clafer Tools - Binary Distributions](https://wiselab.uwaterloo.ca/clafer-tools-binary-distributions/).
 
-1. Download the binaries and unpack `<target directory>` of your choice.
+1. Download the binaries and unpack them into a `<target directory>` of your choice.
 2. Add the `<target directory>` to your system path so that the executables can be found.
+3. The bundle contains `alloy6.2.0.jar`, `chocosolver.jar`, and `ecore2clafer.jar`: use `--tooldir=<target directory>` for `--validate` and `--ecore2clafer`.
 
 ### Installation from Hackage
 
-Clafer is available on [Hackage](http://hackage.haskell.org/package/clafer-0.4.5/) and it can be installed using either [`stack`](https://github.com/commercialhaskell/stack) or [`cabal-install`](https://hackage.haskell.org/package/cabal-install).
-
-#### Installation using `stack`
-
-Stack is the only requirement: no other Haskell tooling needs to be installed because stack will automatically install everything that's needed.
-
-1. [Install `stack`](https://github.com/commercialhaskell/stack#how-to-install)
-   * (first time only) Execute `stack setup`.
-2. Execute `stack install clafer`.
+Clafer is available on [Hackage](https://hackage.haskell.org/package/clafer) and it can be installed using either [`cabal-install`](https://hackage.haskell.org/package/cabal-install) or [`stack`](https://haskellstack.org).
 
 #### Installation using `cabal-install`
 
 Dependencies
 
-* [GHC](https://www.haskell.org/downloads) >= 7.10.3 or 8.0.1 are recommended,
-* `cabal-install` >= 1.22, should be installed together with a GHC distribution,
-* [alex](https://hackage.haskell.org/package/alex),
-* [happy](https://hackage.haskell.org/package/happy).
+* `ghc-9.6.7` or `ghc-9.12.4`
+* `cabal-install-3.10.3` or newer
 
-1. Install GHC
+1. Use [`ghcup`](https://www.haskell.org/ghcup/) to install `ghc` and `cabal`
 2. `cabal update`
-3. `cabal install alex happy`
-4. `cabal install clafer`
-5. on Windows `cd C:\Users\<user>\AppData\Roaming\cabal\x86_64-windows-ghc-8.0.1\clafer-0.4.5`
-6. on Linux `ca ~/.cabal/share/x86_64-linux-ghc-8.0.1/clafer-0.4.5/`
-7. to automatically download Alloy jars, execute
-  * `make alloy4.2.jar`,
-  * move `alloy4.2.jar` to the location of the clafer executable.
+3. `cabal install clafer`
 
+`cabal install clafer` builds the package and installs its executable `clafer` into cabal's `bin` directory (`~/.cabal/bin` or `~/.local/bin`; with cabal 3.12 or newer, `cabal path --installdir` prints it), which must be on your `PATH`. The build tools of the parser are built automatically. The executable is all that is needed: the library is not exposed to GHC unless it is installed with `cabal install --lib clafer`.
+
+Note that `exe:clafer` and `clafer:exe:clafer` are targets inside a project (a checkout of this repository), not of `cabal install` from Hackage.
+
+#### Installation using `stack`
+
+Clafer is not part of Stackage snapshots, so give its version; its dependencies come from the snapshot.
+This release is tested with the snapshot `nightly-2026-11-11`:
+
+1. [Install `stack`](https://docs.haskellstack.org/en/stable/install_and_upgrade/)
+2. `stack install clafer-0.5.8 --resolver nightly-2026-11-11`
+
+The executable is copied to `~/.local/bin`.
+
+#### Tools for validation
+
+To use `--validate`, put `alloy6.2.0.jar` (and `chocosolver.jar` for the Choco output) into a directory, and pass it with `--tooldir=<directory>`.
+In a checkout of this repository, `make alloy6.2.0.jar` downloads the Alloy jar.
+
 ### Installation from the source code
 
 Dependencies
@@ -144,7 +157,7 @@
 #### Building
 
 1. in some `<source directory>` of your choice, execute
-  * `git clone git://github.com/gsdlab/clafer.git`
+  * `git clone https://github.com/gsdlab/clafer.git`
 2. in `<source directory>/clafer`, execute `stack setup`. This will install all dependencies, build tools, and MSYS2 (on Windows).
 3. `cd <source directory>`
   * `make` on Linux/Mac
@@ -157,15 +170,13 @@
   * `stack exec make install to=<target directory>` on Windows
 
 #### Note:
-> On Windows, use `/` with the `make` command instead of `\`, e.g., `make install to=/c/clafer-tools-0.4.5/`
-
-## Integration with Sublime Text 2/3
-
-See [ClaferToolsST](https://github.com/gsdlab/ClaferToolsST)
+> On Windows, use `/` with the `make` command instead of `\`, e.g., `make install to=/c/clafer-tools-0.5.4/`
 
-## Integration with VIM
+## Integration with text editors
 
-See [clafer-vim](https://github.com/wasowski/clafer-vim)
+* VS Code: [clafer-vscode](https://github.com/gsdlab/clafer-vscode)
+* Sublime Text 4: [ClaferToolsST](https://github.com/gsdlab/ClaferToolsST)
+* VIM: [clafer-vim](https://github.com/wasowski/clafer-vim)
 
 ## Usage
 
@@ -174,25 +185,29 @@
 (As printed by `clafer --help`)
 
 ```
-Clafer 0.4.5
+Clafer 0.5.8
 
 clafer [OPTIONS] [FILE]
 
 Common flags:
   -m --mode=CLAFERMODE                    Generated output type. Available
                                           CLAFERMODEs are: 'alloy' (default,
-                                          Alloy 4.2); 'json' (intermediate
+                                          Alloy 6); 'json' (intermediate
                                           representation of Clafer model);
-                                          'clafer' (analyzed and desugared
-                                          clafer model); 'html' (original model
-                                          in HTML); 'graph' (graphical
-                                          representation written in DOT
-                                          language); 'cvlgraph' (cvl notation
-                                          representation written in DOT
-                                          language); 'choco' (Choco constraint
-                                          programming solver). Multiple modes
-                                          can be specified at the same time,
-                                          e.g., '-m alloy -m html'.
+                                          'clafer' (the explicit model, with
+                                          everything written out, as Choco
+                                          solves it; a temporal model with its
+                                          temporal modifiers and operators,
+                                          which only Alloy solves);
+                                          'html' (original model in HTML);
+                                          'graph' (graphical representation
+                                          written in DOT language); 'cvlgraph'
+                                          (cvl notation representation written
+                                          in DOT language); 'choco' (Choco
+                                          constraint programming solver).
+                                          Multiple modes can be specified at
+                                          the same time, e.g., '-m alloy -m
+                                          html'.
   -o --console-output                     Output code on console.
   -i --flatten-inheritance                Flatten inheritance ('alloy' mode
                                           only).
@@ -202,18 +217,29 @@
                                           (experimental).
   -c --check-duplicates                   Check duplicated clafer names in
                                           the entire model.
-  -f --skip-resolver                      Skip name resolution.
+  -f --skip-resolver                      The names of the clafers are their
+                                          UIDs, as in an explicit model: skip
+                                          renaming them. Names must be unique;
+                                          they are still resolved and checked.
+     --explicit                           The model is an explicit model, as
+                                          'clafer -m clafer' prints it, with
+                                          every name a UID and every card
+                                          written out, and its scopes in its
+                                          scope file. Shorthand for -f -k -l
+                                          --ss=none.
   -k --keep-unused                        Keep uninstantated abstract clafers
                                           ('alloy' mode only).
   -s --no-stats                           Don't print statistics.
-  -v --validate                           Validate outputs of all modes. Uses
-                                          '<tooldir>/alloy4.2.jar' for Alloy
-                                          models, '<tooldir>/chocosolver.jar'
-                                          for Alloy models, and Clafer
-                                          translator for desugared Clafer
-                                          models. Use '--tooldir' to override
-                                          the default location ('.') of these
-                                          tools.
+  -v --validate                           Validate outputs of all modes, and
+                                          exit with 1 if a tool rejects one.
+                                          Uses '<tooldir>/alloy6.2.0.jar' for
+                                          Alloy models,
+                                          '<tooldir>/chocosolver.jar' for Choco
+                                          models, dot for graphs, and clafer
+                                          itself for explicit models, which
+                                          must compile to themselves. Use
+                                          '--tooldir' to override the default
+                                          location ('.') of these tools.
      --tooldir=DIR                        Specify the tools directory
                                           ('validate' only). Default: '.'
                                           (current directory).
@@ -233,6 +259,7 @@
                                           only).
   -e --ecore2clafer                       Translate an ECore model into
                                           Clafer.
+     --tl=INT --trace-len                 Define the maximum trace length.
      --ss=SCOPESTRATEGY --scope-strategy  Use scope computation strategy:
                                           none or simple (default).
      --check-afm --afm                    Throws an error if the cardinality
@@ -241,13 +268,47 @@
                                           name'-'least-partially-qualified
                                           name'-'unique ID' map ('.cfr-map').
                                           In Alloy and Choco modes, generate
-                                          the scopes map ('.cfr-scope').
+                                          the scopes map ('.cfr-scope'); in
+                                          Clafer mode, the explicit model's
+                                          scope file with every scope
+                                          ('.des.cfr-scope').
+     --minint=INT                         Smallest integer value ('choco'
+                                          mode only). Default: -128, chosen by
+                                          chocosolver.
+     --maxint=INT                         Largest integer value ('choco' mode
+                                          only). Default: 127, chosen by
+                                          chocosolver.
+     --decimal-digits=INT                 Number of fractional digits of
+                                          decimals ('choco' mode only).
+                                          Default: the most fractional digits
+                                          of the model's decimal literals.
+     --import=FILE                        Compile the model with the model in
+                                          FILE (a path or an http/https URL),
+                                          which is compiled before it (and only
+                                          once, if imported by several files).
+                                          In '//# OPTIONS', FILE is relative to
+                                          the model's folder or URL; options of
+                                          the imported files are combined with
+                                          the model's. Can be repeated.
+     --import-root=DIR                    Allow only local imports inside
+                                          DIR, after resolving '..' and
+                                          symbolic links (command line only).
+                                          Can be repeated; without it, any
+                                          local file can be imported.
+     --public-imports                     Allow only URL imports from public
+                                          addresses, not from loopback,
+                                          private, or link-local ones, without
+                                          a proxy (command line only).
+     --import-base=URL                    The URL from which the model's text
+                                          was read: its imports are relative to
+                                          the URL, and can only be URLs
+                                          (command line only).
   -? --help                               Display help message
   -V --version                            Print version information
      --numeric-version                    Print just the version number
 ```
 
-The dependencies among the command line arguments are described on the [model wiki](http://t3-necsis.cs.uwaterloo.ca:8091/ClaferTools/CommandLineArguments).
+The dependencies among the command line arguments are described on the [model wiki](https://wiselab.uwaterloo.ca/modelwiki/ClaferTools/CommandLineArguments).
 
 Multiple modes can be used at the same time. For example,
 
@@ -258,17 +319,72 @@
 Additionally, `[OPTIONS]` can also be specified directly in the model file by inserting the following compiler directive as the first line of the file:
 
 ```
-//# [OPTIONS]
+//# OPTIONS [OPTIONS]
 ```
 
 for example
 
 ```
-//# --keep-unused -m=alloy
+//# OPTIONS --keep-unused -m=alloy
 ```
 
-Options given at command line override the options given in the file using `//#` which, in turn, override the defaults.
+The directive is only recognized on the very first line of the file and must start exactly with `//# OPTIONS ` (no leading whitespace).
 
+Options given at command line override the options given in the file using `//# OPTIONS` which, in turn, override the defaults.
+An option that the compiler does not know is an error.
+
+### Models in several files
+
+A model can import other files, which are compiled together with it as one model: `--import=FILE`, in its `//# OPTIONS` or on the command line, for example, a model of one system that imports the model of a design space:
+
+```
+//# OPTIONS --import=design-space.cfr
+System : DesignSpace
+```
+
+or `clafer System.cfr --import=design-space.cfr`. The option can be repeated.
+
+* In `//# OPTIONS`, the path is relative to the file containing the directive; on the command line, to the current directory.
+* The model and the imported files can be URLs (`http://`, `https://`): `clafer https://example.org/models/System.cfr`. An import in a model read from a URL is relative to its URL (e.g., `--import=design-space.cfr` reads `https://example.org/models/design-space.cfr`), and such a model can only import URLs, not local files. A local model can import a URL, e.g., a design space published on a server: `//# OPTIONS --import=https://example.org/models/design-space.cfr`. A `file://` URL is a local path.
+* An imported file must be a `.cfr` file: a URL's path, without its query, must end with `.cfr`, also after a redirect, and a URL served as HTML, JSON or XML (by its `Content-Type`) is refused. A model cannot read other files or web pages, whose text the errors would show.
+* The imports are followed transitively: an imported file may import other files. Each file is compiled only once, even if several files import it, and before the files importing it. An import cycle is an error.
+* All files share one namespace, as if they were concatenated: a clafer defined in one file can be used in the others, and the same top-level name in two files is an error. There are no qualified names or separate compilation.
+* The outputs are named after the compiled model (`System.als`, `System.js`, ...), in the current directory for a model read from a URL. Errors give the file in which they are, as in a model of one file: `Compile error at design-space.cfr:12:5...`. The spans of the JSON IR name their file (`{"file": "design-space.cfr", "start": …, "end": …}`), and the HTML output shows each file under its name.
+* The options of all files are combined: the largest `--maxint`, `--decimal-digits`, `--tl` and `--timeout-analysis`, the smallest `--minint`, all modes and imports; `-k`, `-c`, `--check-afm` and `-i` if any file has them, `-f` only if all files have it. The layout (`-l`, `--nl`) and the scope strategy (`--ss`) must be the same in all files. Options of the compilation rather than of the model (`-o`, `-s`, `-v`, `--tooldir`, `-a`, `--self-contained`, `--add-graph`, `--sr`, `--add-comments`, `--meta-data`) are only allowed in the compiled model and on the command line.
+
+* A model that may come from anyone, e.g., in a web tool, is compiled with options that restrict its imports, which only the command line can give: `--import-root=DIR` allows local imports only inside the given folders (after resolving `..` and symbolic links), `--public-imports` allows URL imports only from public addresses, and `--import-base=URL` resolves the imports of a model whose text was read from that URL. `-v` and `--tooldir`, which run tools, can only be given on the command line too: in `//# OPTIONS`, these options are an error.
+
+See [#100](https://github.com/gsdlab/clafer/issues/100) for the design.
+
+### Unique names of clafers (UIDs)
+
+Every clafer has a unique name, its UID, which the outputs use for it: the Alloy signatures, the Choco model, the explicit model (`-m clafer`), the JSON IR, the anchors of the HTML output, and the scope files (`.cfr-scope`). The UID of a clafer is its least-partially-qualified name, with `__` between the names:
+
+```
+size          // root__size: another clafer named size exists
+x
+    size      // x__size
+    color     // color: no other clafer is named so
+```
+
+An apostrophe in a name is `_prime` in the UID (`a'` is `a_prime`), and a UID that would be the same as one before it in the model gets `__2`, `__3`, .... A lookup by name, e.g., in a scope file or claferIG's `i size 3`, takes a UID or a qualified name, which names all the clafers whose paths end with it: `size` names both clafers above, `x__size` the one in `x`, and `root__size` the top-level one. The older form `x::size` and `::size` is read too. A name with `__` is a warning, since `__` separates the names of a UID.
+
+The outputs write the UIDs in the form their language allows: the Alloy output renames a clafer whose UID is an Alloy keyword or a name the Alloy output uses (e.g., `sig` is `sig_1`), and the variables of the Choco output are `$` and the UID (`$x__size`).
+
+### Explicit models
+
+`-m clafer` writes the explicit model of a static model to `model.des.cfr`: the model that chocosolver solves, with every name a UID, every card, group card, `this`, `parent` and `dref` written out, and nesting in braces; with `--meta-data`, also its scope file with every scope, `model.des.cfr-scope`. An explicit model is a Clafer model. Its first line, `//# OPTIONS --explicit`, marks it: for clafer, `--explicit` means `-f -k -l --ss=none`, so the model compiles to itself, and chocosolver reads such a model with its own parser, without the compiler.
+
+### Integer range of the Choco output
+
+The options `--minint` and `--maxint` set the range of integers that the Choco output (`-m choco`) allows, for example, for a model whose attributes and their sums exceed the default range:
+
+```
+//# OPTIONS --minint=-1000 --maxint=1000
+```
+
+Without them, chocosolver chooses the range: -128..127. The options `--minint` and `--maxint` of chocosolver itself override the range of the model. A range that is too small silently restricts the instances, for example, the optimal instances of a multi-objective model; a range that is too large slows down the search. The options do not affect the Alloy output: ClaferIG sets the integer range of Alloy with its option `--maxint` (or `--bitwidth`).
+
 ### Using compiler directives
 
 Compiler directives are comments of the form
@@ -277,7 +393,7 @@
 //# <directive name>
 ```
 
-The following directives are markers of locations in the input files for different purposes:
+The following directives are markers of locations in the input files for different purposes. Each must appear alone on its own line, exactly as written (no leading or trailing whitespace):
 
 * `//# FRAGMENT` - marks the beginning of the new [module fragment](http://gsd.uwaterloo.ca:8888/question/463/multi-fragment-modules).
 * `//# GRAPH` - marks the insertion point for a graph rendering. The graph is only produced in HTML mode with the argument `--add-graph`.
@@ -301,7 +417,7 @@
 
 ## Building
 
-We have switched to [Haskell Tool Stack](https://github.com/commercialhaskell/stack#the-haskell-tool-stack).
+We have switched to [Haskell Tool Stack](https://haskellstack.org/).
 Install the tool first.
 
 ## Testing
@@ -328,6 +444,10 @@
 make test
 ```
 
+It fails if a test suite fails, or if an output of a model in `test/positive` differs from its regression in `test/regression`, has no regression, or a regression has no output.
+The outputs then become the new regressions: a missing regression is created, and a differing one is replaced, unless it has uncommitted changes.
+Review them with `git diff test/regression`, commit them (or restore the ones that are wrong), and run `make test` again.
+
 We do test-driven development in the following way:
 
 1. create a test case Clafer model in either `test/positive` or `test/negative` depending on whether a test case should compile successfully or return an error. For example, see a positive test case [test/positive/redefinition.cfr](https://github.com/gsdlab/clafer/blob/namedDrefs/test/positive/redefinition.cfr).
@@ -339,7 +459,7 @@
 make diffRegressions
 ```
 
-this will show you how the current output diverges from the intended output.
+this will show you how the current output diverges from the intended output. A regression with uncommitted changes, such as an intended output written by hand, is kept.
 
 
 ## Modifying the grammar
diff --git a/clafer.cabal b/clafer.cabal
--- a/clafer.cabal
+++ b/clafer.cabal
@@ -1,96 +1,88 @@
-Name:                   clafer
-Version:                0.4.5
-Synopsis:               Compiles Clafer models to other formats: Alloy, JavaScript, JSON, HTML, Dot.
-Description:            Clafer is a general purpose, lightweight, structural modeling language developed at GSD Lab, University of Waterloo, and MODELS group at IT University of Copenhagen. Lightweight modeling aims at improving the understanding of the problem domain in the early stages of software development and determining the requirements with fewer defects. Clafer's goal is to make modeling more accessible to a wider range of users and domains. The tool provides a reference language implementation. It translates models to other formats (e.g. Alloy, JavaScript, JSON) to allow for reasoning with existing tools.
-Homepage:               http://clafer.org
-License:                MIT
-License-file:           LICENSE
-Author:                 Kacper Bak, Jimmy Liang, Michal Antkiewicz, Ed Zulkoski, Luke Michael Brown, Paulius Juodisius, Rafael Olaechea
-Maintainer:             Michal Antkiewicz <mantkiew@gsd.uwaterloo.ca>
-Stability:              Experimental
-Category:               Model
-Build-type:             Simple
-tested-with:            GHC == 7.10.3
-                      , GHC == 8.0.1
-                      , GHC == 8.0.2
-Cabal-version:          >= 1.22
+cabal-version:          3.8
+name:                   clafer
+version:                0.5.8
+synopsis:               Compiles Clafer models to other formats: Alloy, JavaScript, JSON, HTML, Dot.
+description:            Clafer is a general purpose, lightweight, structural modeling language developed at GSD Lab, University of Waterloo, and MODELS group at IT University of Copenhagen. Lightweight modeling aims at improving the understanding of the problem domain in the early stages of software development and determining the requirements with fewer defects. Clafer's goal is to make modeling more accessible to a wider range of users and domains. The tool provides a reference language implementation. It translates models to other formats (e.g. Alloy, JavaScript, JSON) to allow for reasoning with existing tools.
+homepage:               http://clafer.org
+license:                MIT
+license-file:           LICENSE
+author:                 Kacper Bak, Jimmy Liang, Michał Antkiewicz, Ed Zulkoski, Luke Michael Brown, Paulius Juodisius, Rafael Olaechea
+maintainer:             Michał Antkiewicz <michal.antkiewicz@uwaterloo.ca>
+stability:              Experimental
+category:               Model
+build-type:             Simple
+tested-with:            GHC == 9.6.7 || == 9.12.4
 data-files:             README.md
-                      , CHANGES.md
                       , logo.pdf
                       , Makefile
                       , ecore2clafer.jar
                       , stack.yaml
 extra-source-files:     src/Language/Clafer/clafer.css
+extra-doc-files:        CHANGES.md
 source-repository head
     type:               git
-    location:           git://github.com/gsdlab/clafer.git
-Executable clafer
-    build-tools:        ghc >= 7.10.3
+    location:           https://github.com/gsdlab/clafer.git
+
+flag model-tests
+    description:        Build the model-tests test suite, which compiles the models in test/positive
+                        and test/negative. The models are not part of the package, so it can only be
+                        built in a checkout of the repository.
+    default:            False
+    manual:             True
+
+common shared-deps
     default-language:   Haskell2010
+    ghc-options:        -Wall
+    build-depends:      base >= 4.18.3.0 && < 5
+
+executable clafer
+    import:             shared-deps
     main-is:            clafer.hs
     hs-source-dirs:     src-cmd
-    if impl(ghc >= 8.0)
-      ghc-options: -Wcompat
-      -- -Wnoncanonical-monad-instances -Wnoncanonical-monadfail-instances
-    else
-      build-depends: fail == 4.9.*, semigroups == 0.18.*
-    build-depends:      base >= 4.7.0.1 && < 5
-                      , containers >= 0.5.5.1
-                      , filepath >= 1.3.0.2
-                      , process >= 1.2.0.0
 
-                      , mtl >= 2.1.3.1
-
-                      , cmdargs >= 0.10.12
-                      , split >= 0.2.2
-
-                      , clafer == 0.4.5
+    -- -Wnoncanonical-monad-instances -Wnoncanonical-monadfail-instances
+    build-depends:      process >= 1.6.3.0
+                      , cmdargs >= 0.10.20
+                      , clafer
     other-modules:      Paths_clafer
+    autogen-modules:    Paths_clafer
 
 library
-    build-tools:        ghc >= 7.10.3
-                      , alex >= 3.1.7
-                      , happy >= 1.19.5
-    default-language:   Haskell2010
-    if impl(ghc >= 8.0)
-      ghc-options: -Wcompat
-      -- -Wnoncanonical-monad-instances -Wnoncanonical-monadfail-instances
-    else
-      build-depends: fail == 4.9.*, semigroups == 0.18.*
+    import:             shared-deps
+    build-tool-depends: happy:happy >= 1.20
+                      , alex:alex >= 3.4
     build-depends:      array >= 0.5.0.0
-                      , base >= 4.7.0.1 && < 5
-                      , bytestring >= 0.10.4.0
-                      , containers >= 0.5.5.1
-                      , directory >= 1.2.1.0
-                      , filepath >= 1.3.0.2
-                      , process >= 1.2.0.0
-                      , transformers >= 0.3.0.0
+                      , bytestring >= 0.10.8.1
+                      , containers >= 0.5.7.1
+                      , directory >= 1.3.0.0
+                      , filepath >= 1.4.1.1
+                      , mtl >= 2.2.1
+                      , split >= 0.2.3.2
+                      , process >= 1.4.3.0
+                      , transformers >= 0.6
 
-                      , HTTP >= 4000.2.10
-                      , mtl >= 2.1.3.1
-                      , network >= 2.4.2.3
-                      , parsec >= 3.1.5
-                      , text >= 1.1.0.0
+                      , http-client >= 0.7
+                      , http-client-tls >= 0.3.5
+                      , http-types >= 0.12
+                      , crypton-connection >= 0.3
+                      , data-default >= 0.7
+                      , network >= 3.1
+                      , text >= 2.0
 
-                      , aeson >= 0.11.1.2
-                      , cmdargs >= 0.10.12
-                      , data-stringmap >= 1.0.1.1
-                      , executable-path >= 0.0.3
-                      , file-embed >= 0.0.9
-                      , json-builder >= 0.3
-                      , lens >= 4.6.0.1
-                      , lens-aeson >= 1.0.0.5
-                      , network-uri >= 2.5.0.0
-                      , string-conversions >= 0.3.0.3
-                      , split >= 0.2.2
-                      , transformers-compat >= 0.3
-                      , mtl-compat >= 0.2.1
+                      , aeson >= 1.1.2.0
+                      , cmdargs >= 0.10.20
+                      , file-embed >= 0.0.10
+                      , lens >= 4.15.4
+                      , lens-aeson >= 1.0.2
+                      , network-uri >= 2.6.1.0
+                      , string-conversions >= 0.4.0.1
 
     hs-source-dirs:     src
-    ghc-options:        -Wall -fno-warn-orphans
+    ghc-options:        -fno-warn-orphans
     exposed-modules:    Language.Clafer
                       , Language.ClaferT
                       , Language.Clafer.ClaferArgs
+                      , Language.Clafer.Import
                       , Language.Clafer.Comments
                       , Language.Clafer.Common
                       , Language.Clafer.Css
@@ -103,7 +95,11 @@
                       , Language.Clafer.Front.ParClafer
                       , Language.Clafer.Front.PrintClafer
                       , Language.Clafer.Generator.Alloy
+                      , Language.Clafer.Generator.AlloyLtl
+                      , Language.Clafer.Generator.AlloyNames
                       , Language.Clafer.Generator.Choco
+                      , Language.Clafer.Generator.ChocoModel
+                      , Language.Clafer.Generator.Explicit
                       , Language.Clafer.Generator.Concat
                       , Language.Clafer.Generator.Graph
                       , Language.Clafer.Generator.Html
@@ -114,62 +110,62 @@
                       , Language.Clafer.Intermediate.ResolverInheritance
                       , Language.Clafer.Intermediate.ResolverName
                       , Language.Clafer.Intermediate.ResolverType
+                      , Language.Clafer.Intermediate.ResolverRoot
                       , Language.Clafer.Intermediate.ScopeAnalysis
                       , Language.Clafer.Intermediate.SimpleScopeAnalyzer
                       , Language.Clafer.Intermediate.StringAnalyzer
                       , Language.Clafer.Intermediate.Tracing
+                      , Language.Clafer.Intermediate.UIDs
                       , Language.Clafer.Intermediate.Transformer
                       , Language.Clafer.Intermediate.TypeSystem
                       , Language.Clafer.Optimizer.Optimizer
                       , Language.Clafer.SplitJoin
                       , Paths_clafer
-    other-modules:      GetURL
+    autogen-modules:    Paths_clafer
+    other-modules:      Control.Monad.Trans.List
 
 Test-Suite test-suite
-    build-tools:        ghc >= 7.10.3
-    default-language:   Haskell2010
+    import:             shared-deps
     type:               exitcode-stdio-1.0
     main-is:            test-suite.hs
     hs-source-dirs:     test
-    if impl(ghc >= 8.0)
-      ghc-options: -Wcompat
-      -- -Wnoncanonical-monad-instances -Wnoncanonical-monadfail-instances
-    else
-      build-depends: fail == 4.9.*, semigroups == 0.18.*
-    build-depends:      base >= 4.7.0.1 && < 5
-                      , containers >= 0.5.5.1
-                      , directory >= 1.2.1.0
-                      , filepath >= 1.3.0.2
-
-                      , HUnit >= 1.2.5.2
-                      , mtl >= 2.1.3.1
-                      , QuickCheck >= 2.6
-
-                      , data-stringmap >= 1.0.1.1
+    build-depends:      containers >= 0.5.7.1
+                      , directory >= 1.3.0.0
+                      , aeson >= 1.1.2.0
                       , lens >= 4.6.0.1
-                      , lens-aeson >= 1.0.0.5
-                      , tasty >= 0.10.1.2
+                      , network-uri >= 2.6.1.0
+                      , network >= 3.1
+                      , tasty >= 0.11.3
                       , tasty-hunit >= 0.9.2
-                      , tasty-th >= 0.1.3
-                      , transformers-compat >= 0.3
-                      , mtl-compat >= 0.2.1
-                      , clafer == 0.4.5
-
-    ghc-options:        -Wall
+                      , tasty-th >= 0.1.7
+                      , clafer
 
     other-modules:      Functions
-                      , Suite.Positive
-                      , Suite.Negative
                       , Suite.SimpleScopeAnalyser
                       , Suite.Redefinition
                       , Suite.TypeSystem
 
+Test-Suite model-tests
+    import:             shared-deps
+    type:               exitcode-stdio-1.0
+    main-is:            model-tests.hs
+    hs-source-dirs:     test
+    if !flag(model-tests)
+        buildable:      False
+    build-depends:      containers >= 0.5.7.1
+                      , directory >= 1.3.0.0
+                      , tasty >= 0.11.3
+                      , tasty-hunit >= 0.9.2
+                      , tasty-th >= 0.1.7
+                      , clafer
+    other-modules:      Functions
+                      , Suite.Positive
+                      , Suite.Negative
+
 Test-suite doctests
-    build-tools:        ghc >= 7.10.3
-    default-language:   Haskell2010
+    import:             shared-deps
     type:               exitcode-stdio-1.0
-    ghc-options:        -threaded -Wall
+    ghc-options:        -threaded
     main-is:            doctests.hs
     hs-source-dirs:     test
-    build-depends:      base
-                      , doctest >= 0.10.1
+    build-depends:      doctest >= 0.11.4
diff --git a/src-cmd/clafer.hs b/src-cmd/clafer.hs
--- a/src-cmd/clafer.hs
+++ b/src-cmd/clafer.hs
@@ -19,31 +19,38 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
 -}
-{-# LANGUAGE DeriveDataTypeable, NamedFieldPuns #-}
 module Main where
 
 import Prelude hiding (writeFile, readFile, print, putStrLn)
 
 import Data.Functor (void)
+import System.Console.CmdArgs (cmdArgsRun)
+import System.Exit (exitFailure)
 import System.IO
 import System.Timeout
 import System.Process (system)
 
 import Language.Clafer
+import Language.Clafer.Import
 
 main :: IO ()
 main = do
-  (args', model) <- mainArgs
-  let timeInSec = (timeout_analysis args') * 10^(6::Integer)
-  if timeInSec > 0
-    then timeout timeInSec $ start args' model
-    else Just `fmap` start args' model
-  return ()
-
-start :: ClaferArgs -> InputModel-> IO ()
-start args' model = if ecore2clafer args'
-  then runEcore2Clafer (file args') $ (tooldir args')
-  else runCompiler Nothing args' model
+  argsFromCmd <- cmdArgsRun claferMode
+  if ecore2clafer argsFromCmd
+    then runEcore2Clafer (file argsFromCmd) $ tooldir argsFromCmd
+    else do
+      -- the model, the files it imports, and the options of all of them
+      model <- readModel argsFromCmd
+      case model of
+        Left message -> do
+          putStrLn $ "\nError...\n" ++ message
+          exitFailure
+        Right (args', modelFiles) -> do
+          let timeInSec = (timeout_analysis args') * 10^(6::Integer)
+          _ <- if timeInSec > 0
+                 then timeout timeInSec $ runCompiler Nothing args' modelFiles
+                 else Just `fmap` runCompiler Nothing args' modelFiles
+          return ()
 
 runEcore2Clafer :: FilePath -> FilePath -> IO ()
 runEcore2Clafer    ecoreFile toolPath
diff --git a/src/Control/Monad/Trans/List.hs b/src/Control/Monad/Trans/List.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Monad/Trans/List.hs
@@ -0,0 +1,167 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE Safe #-}
+{-# LANGUAGE UndecidableInstances #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Monad.Trans.List
+-- Copyright   :  (c) Andy Gill 2001,
+--                (c) Oregon Graduate Institute of Science and Technology, 2001
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  R.Paterson@city.ac.uk
+-- Stability   :  experimental
+-- Portability :  portable
+--
+-- The ListT monad transformer, adding backtracking to a given monad,
+-- which must be commutative.
+-----------------------------------------------------------------------------
+
+module Control.Monad.Trans.List
+  {-# DEPRECATED "This transformer is invalid on most monads" #-} (
+    -- * The ListT monad transformer
+    ListT(..),
+    mapListT,
+    -- * Lifting other operations
+    liftCallCC,
+    liftCatch,
+  ) where
+
+import Control.Monad.IO.Class
+import Control.Monad.Signatures
+import Control.Monad.Trans.Class
+import Data.Functor.Classes
+import Data.Functor.Contravariant
+import Control.Applicative
+import Control.Monad
+import qualified Control.Monad.Fail as Fail
+import Control.Monad.Error.Class (MonadError(..))
+import Control.Monad.Fix
+import Control.Monad.Zip (MonadZip(mzipWith))
+
+-- | Parameterizable list monad, with an inner monad.
+--
+-- /Note:/ this does not yield a monad unless the argument monad is commutative.
+newtype ListT m a = ListT { runListT :: m [a] }
+
+instance (Eq1 m) => Eq1 (ListT m) where
+    liftEq eq (ListT x) (ListT y) = liftEq (liftEq eq) x y
+    {-# INLINE liftEq #-}
+
+instance (Ord1 m) => Ord1 (ListT m) where
+    liftCompare comp (ListT x) (ListT y) = liftCompare (liftCompare comp) x y
+    {-# INLINE liftCompare #-}
+
+instance (Read1 m) => Read1 (ListT m) where
+    liftReadsPrec rp rl = readsData $
+        readsUnaryWith (liftReadsPrec rp' rl') "ListT" ListT
+      where
+        rp' = liftReadsPrec rp rl
+        rl' = liftReadList rp rl
+
+instance (Show1 m) => Show1 (ListT m) where
+    liftShowsPrec sp sl d (ListT m) =
+        showsUnaryWith (liftShowsPrec sp' sl') "ListT" d m
+      where
+        sp' = liftShowsPrec sp sl
+        sl' = liftShowList sp sl
+
+instance (Eq1 m, Eq a) => Eq (ListT m a) where (==) = eq1
+instance (Ord1 m, Ord a) => Ord (ListT m a) where compare = compare1
+instance (Read1 m, Read a) => Read (ListT m a) where readsPrec = readsPrec1
+instance (Show1 m, Show a) => Show (ListT m a) where showsPrec = showsPrec1
+
+-- | Map between 'ListT' computations.
+--
+-- * @'runListT' ('mapListT' f m) = f ('runListT' m)@
+mapListT :: (m [a] -> n [b]) -> ListT m a -> ListT n b
+mapListT f m = ListT $ f (runListT m)
+{-# INLINE mapListT #-}
+
+instance (Functor m) => Functor (ListT m) where
+    fmap f = mapListT $ fmap $ map f
+    {-# INLINE fmap #-}
+
+instance (Foldable f) => Foldable (ListT f) where
+    foldMap f (ListT a) = foldMap (foldMap f) a
+    {-# INLINE foldMap #-}
+
+instance (Traversable f) => Traversable (ListT f) where
+    traverse f (ListT a) = ListT <$> traverse (traverse f) a
+    {-# INLINE traverse #-}
+
+instance (Applicative m) => Applicative (ListT m) where
+    pure a  = ListT $ pure [a]
+    {-# INLINE pure #-}
+    f <*> v = ListT $ (<*>) <$> runListT f <*> runListT v
+    {-# INLINE (<*>) #-}
+
+instance (Applicative m) => Alternative (ListT m) where
+    empty   = ListT $ pure []
+    {-# INLINE empty #-}
+    m <|> n = ListT $ (++) <$> runListT m <*> runListT n
+    {-# INLINE (<|>) #-}
+
+instance (Monad m) => Monad (ListT m) where
+    m >>= k  = ListT $ do
+        a <- runListT m
+        b <- mapM (runListT . k) a
+        return (concat b)
+    {-# INLINE (>>=) #-}
+
+instance (Monad m) => Fail.MonadFail (ListT m) where
+    fail _ = ListT $ return []
+    {-# INLINE fail #-}
+
+instance (Monad m) => MonadPlus (ListT m) where
+    mzero       = ListT $ return []
+    {-# INLINE mzero #-}
+    m `mplus` n = ListT $ do
+        a <- runListT m
+        b <- runListT n
+        return (a ++ b)
+    {-# INLINE mplus #-}
+
+instance (MonadFix m) => MonadFix (ListT m) where
+    mfix f = ListT $ mfix (runListT . f . head) >>= \ xs -> case xs of
+        [] -> return []
+        x:_ -> liftM (x:) (runListT (mfix (mapListT (liftM tail) . f)))
+    {-# INLINE mfix #-}
+
+instance MonadTrans ListT where
+    lift m = ListT $ do
+        a <- m
+        return [a]
+    {-# INLINE lift #-}
+
+instance (MonadIO m) => MonadIO (ListT m) where
+    liftIO = lift . liftIO
+    {-# INLINE liftIO #-}
+
+instance (MonadZip m) => MonadZip (ListT m) where
+    mzipWith f (ListT a) (ListT b) = ListT $ mzipWith (zipWith f) a b
+    {-# INLINE mzipWith #-}
+
+instance Contravariant m => Contravariant (ListT m) where
+    contramap f = ListT . contramap (fmap f) . runListT
+    {-# INLINE contramap #-}
+
+instance (MonadError e m) => MonadError e (ListT m) where
+    throwError = lift . throwError
+    {-# INLINE throwError #-}
+    catchError = liftCatch catchError
+    {-# INLINE catchError #-}
+
+-- | Lift a @callCC@ operation to the new monad.
+liftCallCC :: CallCC m [a] [b] -> CallCC (ListT m) a b
+liftCallCC callCC f = ListT $
+    callCC $ \ c ->
+    runListT (f (\ a -> ListT $ c [a]))
+{-# INLINE liftCallCC #-}
+
+-- | Lift a @catchE@ operation to the new monad.
+liftCatch :: Catch e m [a] -> Catch e (ListT m) a
+liftCatch catchE m h = ListT $ runListT m
+    `catchE` \ e -> runListT (h e)
+{-# INLINE liftCatch #-}
diff --git a/src/GetURL.hs b/src/GetURL.hs
deleted file mode 100644
--- a/src/GetURL.hs
+++ /dev/null
@@ -1,24 +0,0 @@
--- (c) Simon Marlow 2011, see the file LICENSE for copying terms.
-
--- Simple wrapper around HTTP, allowing proxy use
-
-module GetURL (getURL) where
-
-import Network.HTTP
-import Network.Browser
-import Network.URI
-
-getURL :: String -> IO String
-getURL url = do
-  Network.Browser.browse $ do
-    setCheckForProxy True
-    setDebugLog Nothing
-    setOutHandler (const (return ()))
-    (_, rsp) <- request (getRequest' (escapeURIString isUnescapedInURI url))
-    return (rspBody rsp)
-  where
-   getRequest' :: String -> Request String
-   getRequest' urlString =
-    case parseURI urlString of
-      Nothing -> error ("getRequest: Not a valid URL - " ++ urlString)
-      Just u  -> mkRequest GET u
diff --git a/src/Language/Clafer.hs b/src/Language/Clafer.hs
--- a/src/Language/Clafer.hs
+++ b/src/Language/Clafer.hs
@@ -98,6 +98,8 @@
 import           Control.Monad
 import           Control.Monad.State
 import           Data.Aeson
+import qualified Data.Aeson.Key as Key
+import qualified Data.Aeson.KeyMap as KeyMap
 import           Data.Data.Lens
 import           Data.Either
 import           Data.List
@@ -108,6 +110,7 @@
 import           System.FilePath (dropExtension, takeBaseName)
 import           System.IO
 import           System.Process (readProcessWithExitCode, system)
+import           System.Environment (getExecutablePath)
 
 import           Language.Clafer.ClaferArgs hiding (Clafer)
 import qualified Language.Clafer.ClaferArgs  as Mode (ClaferMode (Clafer))
@@ -121,14 +124,19 @@
 import           Language.Clafer.Front.ParClafer
 import           Language.Clafer.Front.PrintClafer
 import           Language.Clafer.Generator.Alloy
+import           Language.Clafer.Generator.AlloyLtl
+import           Language.Clafer.Generator.AlloyNames (alloyNames, toAlloyNames)
 import           Language.Clafer.Generator.Choco
 import           Language.Clafer.Generator.Concat
+import           Language.Clafer.Generator.Explicit
 import           Language.Clafer.Generator.Graph
 import           Language.Clafer.Generator.Html
 import           Language.Clafer.Generator.Stats
+import           Language.Clafer.Import
 import           Language.Clafer.Intermediate.Desugarer
 import           Language.Clafer.Intermediate.Intclafer
 import           Language.Clafer.Intermediate.Resolver
+import           Language.Clafer.Intermediate.ResolverType (redundantExps)
 import           Language.Clafer.Intermediate.ScopeAnalysis
 import           Language.Clafer.Intermediate.StringAnalyzer
 import           Language.Clafer.Intermediate.Tracing
@@ -140,16 +148,18 @@
 
 type InputModel = String
 
--- | Run the Clafer compiler.
+-- | Run the Clafer compiler on the files of a model, as read by 'readModel': the imported
+-- files and the model, compiled together.
 -- mURL = Nothing means compile the top-level module
 -- mURL = Just url means compile an imported module from the given url
-runCompiler :: Maybe URL -> ClaferArgs -> InputModel -> IO ()
-runCompiler    mURL         args'         inputModel =
+runCompiler :: Maybe URL -> ClaferArgs -> [ModelFile] -> IO ()
+runCompiler    mURL         args'         modelFiles =
   do
     hSetBuffering stdout LineBuffering
     result <- runClaferT args' $
       do
         forM_ (fragments inputModel) addModuleFragment
+        modifyEnv $ \env -> env{inputFiles = modelFiles}
         parse
         iModule <- desugar mURL
         {- need to runCompiler on imports
@@ -164,15 +174,20 @@
         fs <- save args'
 
         when (validate args') $ liftIO $ do
-            putStrLn $ "[clafer]              Validating " ++ file args'            
+            putStrLn $ "[clafer]              Validating " ++ file args'
 
         when (validate args') $ liftIO $ do
-          forM_ fs (runValidate args')
+          failed <- concat <$> forM fs (runValidate args')
           putStrLn "\n"
+          -- an output that its tool rejects is an error, as a compile error is
+          unless (null failed) $ do
+            putStrLn $ "[clafer]              Validation failed: " ++ intercalate ", " failed
+            exitFailure
     when (Html `elem` mode args') $
       htmlCatch result args' inputModel
     result `cth` handleErrs
   where
+  inputModel = modelText modelFiles
   cth (Left err) f = f err
   cth (Right r)  _ = return r
   fragments model = map unlines $ fragments' $ lines model
@@ -186,7 +201,7 @@
        let result = (if (self_contained args'')
                      then Css.header ++ "<style>" ++ Css.css ++ "</style>" ++ "</head>\n<body>\n<pre>\n"
                      else "")
-                     ++ highlightErrors model err ++
+                     ++ highlightErrorsIn modelFiles model err ++
                      (if (self_contained args'')
                       then "\n</pre>\n</html>"
                       else "")
@@ -203,14 +218,16 @@
   -- only care about the position relative to
   handleErr (ParseErr ErrPos{modelPos = Pos l c} mesg) =
     do
-      putStrLn $ "\nParse failed at line " ++ show l ++ " column " ++ show c ++ "..."
+      putStrLn $ "\nParse failed at " ++ errorPosition l c ++ "..."
       putStrLn mesg
       exitFailure
   handleErr (SemanticErr ErrPos{modelPos = Pos l c} mesg) =
     do
-      putStrLn $ "\nCompile error at line " ++ show l ++ " column " ++ show c ++ "..."
+      putStrLn $ "\nCompile error at " ++ errorPosition l c ++ "..."
       putStrLn mesg
       exitFailure
+  -- the file and the position in it: "file.cfr:3:5"
+  errorPosition l c = let (path, l') = modelPosition modelFiles l in path ++ ":" ++ show l' ++ ":" ++ show c
 
 save :: MonadIO m => ClaferArgs -> ClaferT m [ String ]
 save args'=
@@ -220,11 +237,11 @@
     -- print stats only once
     unless (no_stats args') $ liftIO $ printStats results
     -- save the outputs
-    (iModule, _, _) <- getIr
-    forM results $ saveResult iModule resultsMap
+    (iModule, genv, _) <- getIr
+    forM results $ saveResult (iModule, genv) resultsMap
   where
     -- saveResult :: MonadIO m => CompilerResult -> IModule -> (Map.Map ClaferMode CompilerResult) -> ClaferT m String
-    saveResult iModule' resultsMap' result@CompilerResult { extension } = do
+    saveResult (iModule', genv') resultsMap' result@CompilerResult { extension, scopesList } = do
       result' <- if (add_graph args') && (Html `elem` (mode args') && ("dot" `isSuffixOf` (extension)))
             then do
                    ast' <- getAst
@@ -232,7 +249,7 @@
                    return $ summary graph result
             else return result
       let f = dropExtension $ file args'
-      let f' = f ++ "." ++ extension
+      let f' = f ++ "." ++ if extension == "tmp.als" then "als" else extension
       liftIO $ if console_output args' then putStrLn (outputCode result') else writeFile f' (outputCode result')
       liftIO $ when (alloy_mapping args') $ writeFile (f ++ ".map") $ show (mappingToAlloy result')
       let
@@ -240,6 +257,9 @@
         qNameMaps = deriveQNameMaps iModule'
       liftIO $ when (meta_data args') $ writeFile (f ++ ".cfr-map") $ generateJSONnameUIDMap qNameMaps
       liftIO $ when (meta_data args' && inScopeModes) $ writeFile (f ++ ".cfr-scope") $ generateJSONScopes qNameMaps $ getScopesList resultsMap'
+      -- the explicit form's scope file: every scope chocosolver solves it with
+      liftIO $ when (meta_data args' && extension == "des.cfr") $ writeFile (f ++ ".des.cfr-scope") $
+        snd $ genExplicitModule (iModule', genv') scopesList (minint args', maxint args') (decimal_digits args') Nothing
       return f'
     saveResult _ _ NoCompilerResult { reason } = do
       liftIO $ putStrLn reason
@@ -253,6 +273,7 @@
     inScopeModes :: Bool
     inScopeModes =
       Alloy `elem` mode args' ||
+      AlloyLtl `elem` mode args' ||
       Choco `elem` mode args'
 
     getScopesList :: Map.Map ClaferMode CompilerResult -> [(UID, Integer)]
@@ -268,7 +289,8 @@
            else scopesList $ fromJust alloyResult
 
 summary :: String -> CompilerResult -> CompilerResult
-summary graph result = result{outputCode=unlines $ summary' graph ("<pre>" ++ statistics result ++ "</pre>") (lines $ outputCode result)}
+summary graph result@CompilerResult{} = result{outputCode=unlines $ summary' graph ("<pre>" ++ statistics result ++ "</pre>") (lines $ outputCode result)}
+summary _     noResult = noResult
 
 summary' :: String -> String -> [String] -> [String]
 summary' _ _ [] = []
@@ -278,25 +300,49 @@
 summary' graph stats ("<!-- # CVLGRAPH /-->":xs) = graph:summary' graph stats xs
 summary' graph stats (x:xs) = x:summary' graph stats xs
 
-runValidate :: ClaferArgs -> String -> IO ()
-runValidate args' fo = do
-  let path = (tooldir args') ++ "/"
-  let modes = mode args'
-  let fo' = "\""  ++ fo ++ "\""
-  when (Alloy `elem` modes && ".als" `isSuffixOf` fo) $ do
-    void $ system $ validateAlloy path ++ fo'
-  when (Choco `elem` modes && ".js" `isSuffixOf` fo) $ do
-    void $ system $ validateChoco path ++ fo'
-  when (Graph `elem` modes && ".dot" `isSuffixOf` fo) $ do
-    liftIO $ putStrLn ("=========== Parsing+Generating   " ++ fo ++ " =============")
-    void $ system $ validateGraph ++ fo'
-  -- when (Mode.Clafer `elem` modes && ".des.cfr" `isSuffixOf` fo) $ do
-  --   liftIO $ putStrLn ("=========== Parsing+Typechecking " ++ fo ++ " =============")
-  --   liftIO $ putStrLn $ validateClafer path ++ fo'
-  --   void $ system $  validateClafer path ++ fo'
+-- | Validates an output with its tool; returns the output if the tool rejects it. A counterexample
+--   is not a failure: the tool exits with 0.
+runValidate :: ClaferArgs -> String -> IO [String]
+runValidate args' fo
+  | Alloy `elem` modes && ".als" `isSuffixOf` fo = do
+    putStrLn ("=========== Running the commands of " ++ fo ++ " =============")
+    run $ validateAlloy path ++ fo
+  | Choco `elem` modes && ".js" `isSuffixOf` fo =
+    run $ validateChoco path ++ fo
+  | Graph `elem` modes && ".dot" `isSuffixOf` fo = do
+    putStrLn ("=========== Parsing+Generating   " ++ fo ++ " =============")
+    run $ validateGraph ++ fo
+  | Mode.Clafer `elem` modes && ".des.cfr" `isSuffixOf` fo = do
+    putStrLn ("=========== Compiling the explicit model " ++ fo ++ " =============")
+    validateClafer fo
+  | otherwise = return []
+  where
+  path = tooldir args' ++ "/"
+  modes = mode args'
+  run command = do
+    code <- system command
+    return [ fo | code /= ExitSuccess ]
 
+-- | The explicit model compiles to itself: clafer -m clafer on it prints it (its first line,
+--   //# OPTIONS --explicit, gives the options).
+validateClafer :: FilePath -> IO [String]
+validateClafer fo = do
+  clafer' <- getExecutablePath
+  explicit <- readFile fo
+  (code, out, err) <- readProcessWithExitCode clafer' ["-s", "-m", "clafer", "-o", fo] ""
+  case code of
+    -- the console output ends with one more newline
+    ExitSuccess | dropWhileEnd (== '\n') out == dropWhileEnd (== '\n') explicit -> return []
+                | otherwise       -> do
+                    putStrLn $ "The explicit model does not compile to itself: " ++ fo
+                    return [fo]
+    _ -> do
+      putStrLn $ out ++ err
+      return [fo]
+
+-- | Runs all commands (the default run command if there are none) and prints the instances and counterexamples.
 validateAlloy :: String -> String
-validateAlloy path = "java -cp \"" ++ path ++ "alloy4.2.jar\" edu.mit.csail.sdg.alloy4whole.ExampleUsingTheCompiler "
+validateAlloy path = "java --enable-native-access=ALL-UNNAMED -jar \"" ++ path ++ "alloy6.2.0.jar\" exec -c \"*\" -t table -o - "
 
 validateChoco :: String -> String
 validateChoco path = "java -jar \"" ++ path ++ "chocosolver.jar\" -v --file "
@@ -304,8 +350,6 @@
 validateGraph :: String
 validateGraph = "dot -Tsvg -O "
 
--- validateClafer :: String -> String
--- validateClafer path = "\""  ++ path ++ "clafer\" -s -k -m=clafer "
 
 
 -- | Add a new fragment to the model. Fragments should be added in order.
@@ -314,7 +358,7 @@
   do
     env <- getEnv
     let modelFrags' = modelFrags env ++ [i]
-    let frags' = frags env ++ [(endPos $ concat modelFrags')]
+    let frags' = frags env ++ [endPos $ concat modelFrags']
     putEnv env{ modelFrags = modelFrags', frags = frags' }
   where
   endPos "" = Pos 1 1
@@ -323,7 +367,7 @@
     where
     input' = lines' model
     line' = toInteger $ length input'
-    column' = 1 + (toInteger $ length $ last input')
+    column' = 1 + toInteger (length $ last input')
     -- Can't use the builtin lines because it ignores the last empty lines (as of base 4.5).
     lines' "" = [""]
     lines' input'' =
@@ -366,15 +410,34 @@
 
     (astErr, otherTokens') <- (parseFrag $ args env) completeModel
     ast <- liftParseErr astErr
+    case sameLineClafers ast of
+      (span', name') : _ -> throwErr (ParseErr span' $ "clafer " ++ name' ++ " must start on a new line" :: CErr Span)
+      []                 -> return ()
 
     putEnv env{ cAst = Just ast, astModuleTrace = traceAstModule ast, otherTokens = otherTokens' }
   where
+  -- Elements have no separator in the grammar, so `b : B A 3` parses as two
+  -- sibling clafers, b : B and A 3. Returns the clafers which start on the same
+  -- line as their previous sibling clafer.
+  sameLineClafers :: Module -> [(Span, String)]
+  sameLineClafers (Module _ decls') = concatMap sameLine $ elementLists [ e | ElementDecl _ e <- decls' ]
+    where
+    elementLists es = es : concatMap elementLists [ es' | ElementsList _ es' <- map nested es ]
+    nested (Subclafer _ (Clafer _ _ _ _ _ _ _ _ _ _ elements')) = elements'
+    nested (ClaferUse _ _ _ elements') = elements'
+    nested e = ElementsEmpty $ getSpan e
+    sameLine es = [ (s2, n2) | ((Span (Pos l1 _) _, _), (s2@(Span (Pos l2 _) _), n2)) <- zip clafers' (drop 1 clafers'), l1 == l2 ]
+      where
+      clafers' = mapMaybe claferStart es
+    claferStart (Subclafer s (Clafer _ _ _ _ (PosIdent (_, n)) _ _ _ _ _ _)) = Just (s, n)
+    claferStart (ClaferUse s name' _ _) = Just (s, "`" ++ printTree name')
+    claferStart _ = Nothing
   parseFrag :: (Monad m) => ClaferArgs -> String    -> ClaferT m (Err Module, [Token])
   parseFrag                 args'         inputModel = do
     let model' = if (not $ no_layout args') && (new_layout args') then resLayout inputModel else inputModel
     let allTokens = myLexer model'
     let (parseableTokens, otherTokens') = partition isParseable allTokens
-    tokens2 <- if not ((new_layout args') || (no_layout args')) then resolveLayout parseableTokens else return parseableTokens
+    tokens2 <- if not ((new_layout args') || (no_layout args')) then resolveLayout otherTokens' parseableTokens else return parseableTokens
     return (pModule tokens2, otherTokens')
     where
       isParseable (PT _ (T_PosLineComment _))  = False
@@ -393,45 +456,85 @@
 compile desugaredMod = do
     env <- getEnv
     let clafersWithKeyWords = foldMapIR isKeyWord desugaredMod
-    when (""/=clafersWithKeyWords) $ throwErr (ClaferErr $ ("The model contains clafers with keywords as names in the following places:\n"++) $ clafersWithKeyWords :: CErr Span)
+    when (""/=clafersWithKeyWords) $ throwErr (ClaferErr $ ("The model contains clafers with keywords as names in the following places:\n"++) clafersWithKeyWords :: CErr Span)
     ir <- analyze (args env) desugaredMod
     let (imodule, _, _) = ir
 
     let spanList = foldMapIR gt1 imodule
-    when ((afm $ args env) && spanList/="") $ throwErr (ClaferErr $ ("The model is not an attributed feature model.\nThe following places contain cardinality larger than 1:\n"++) $ spanList :: CErr Span)
+    when (afm (args env) && spanList/="") $ throwErr (ClaferErr $ ("The model is not an attributed feature model.\nThe following places contain cardinality larger than 1:\n"++) spanList :: CErr Span)
+    let unsatisfiableGroups' = unsatisfiableGroups imodule
+    unless (null unsatisfiableGroups') $ throwErrs unsatisfiableGroups'
     putEnv $ env{ cIr = Just ir }
     where
       isKeyWord :: Ir -> String
-      isKeyWord (IRClafer IClafer{_cinPos = (Span (Pos l c) _) ,_ident=i}) = if (i `elem` keywordIdents) then ("Line " ++ show l ++ " column " ++ show c ++ "\n") else ""
+      isKeyWord (IRClafer IClafer{_cinPos = (Span (Pos l c) _) ,_ident=i}) =
+        if i `elem` keywordIdents
+        then "Line " ++ show l ++ " column " ++ show c ++ "\n"
+        else ""
       isKeyWord _ = ""
       gt1 :: Ir -> String
-      gt1 (IRClafer (IClafer (Span (Pos l c) _) False _ _ _ _ _ _ (Just (_, m)) _ _)) = if (m > 1 || m < 0) then ("Line " ++ show l ++ " column " ++ show c ++ "\n") else ""
+      gt1 (IRClafer (IClafer (Span (Pos l c) _) IClaferModifiers{_abstract=False} _ _ _ _ _ _ (Just (_, m)) _ _)) = if m > 1 || m < 0 then "Line " ++ show l ++ " column " ++ show c ++ "\n" else ""
       gt1 _ = ""
 
 
--- | Splits the AST into their fragments, and generates the output for each fragment.
+-- | The spans of the JSON output in the files of the model:
+--   @{"file": "lib.cfr", "start": {"line": 3, "column": 5}, "end": ...}@, with the lines in the file.
+--   Unchanged if the files are not known.
+spansInFiles :: [ModelFile] -> Value -> Value
+spansInFiles [] value = value
+spansInFiles files value = inFiles value
+  where
+  inFiles (Object o) = case (KeyMap.lookup (Key.fromString "start") o, KeyMap.lookup (Key.fromString "end") o) of
+    (Just (Object start'), Just (Object end'))
+      | KeyMap.size o == 2
+      , Just (Number line1) <- KeyMap.lookup (Key.fromString "line") start'
+      , Just (Number line2) <- KeyMap.lookup (Key.fromString "line") end' ->
+        let (path, line1') = modelPosition files (round line1)
+            -- the end is in the same file, relative to the start
+            line2' = round line2 - round line1 + line1'
+        in object [ Key.fromString "file" .= path
+                  , Key.fromString "start" .= KeyMap.insert (Key.fromString "line") (toJSON line1') start'
+                  , Key.fromString "end" .= KeyMap.insert (Key.fromString "line") (toJSON line2') end' ]
+    _ -> Object $ fmap inFiles o
+  inFiles (Array a) = Array $ fmap inFiles a
+  inFiles other = other
+
+-- | Splits the AST into their fragments, and generates the output for each fragment; each file
+--   of the model starts with its name.
 generateHtml :: ClaferEnv -> String
 generateHtml env =
-    let (Just (Module _ decls')) = cAst env;
-        cargs = args env;
-        irMap = irModuleTrace env;
-        comments = if add_comments cargs then getComments $ unlines $ modelFrags env else [];
-    in (if (self_contained cargs) then Css.header ++ "<style>" ++ Css.css ++ "</style></head>\n<body>\n" else "")
-       ++ (unlines $ genFragments decls' (frags env) irMap comments) ++
-       (if (self_contained cargs) then "</body>\n</html>" else "")
-
+  case cAst env of
+    Nothing -> ""
+    (Just (Module _ decls')) ->
+      let
+          cargs = args env
+          irMap = irModuleTrace env
+          comments = if add_comments cargs then getComments $ unlines $ modelFrags env else [];
+          -- the fragment markers and the names of the files, where they start
+          markers = sortOn fst $ map (\frg -> (frg, fragmentMarker)) (frags env)
+                                 ++ [ (Pos line' 1, printFileHeader path) | (line', path) <- fileStarts (inputFiles env) ]
+      in (if self_contained cargs then Css.header ++ "<style>" ++ Css.css ++ "</style></head>\n<body>\n" else "")
+        ++ unlines (genFragments decls' markers irMap comments) ++
+        (if self_contained cargs then "</body>\n</html>" else "")
   where
     lne :: Declaration -> Pos
     lne (ElementDecl (Span p _) _) = p
     lne (EnumDecl (Span p _) _  _) = p
-    genFragments :: [Declaration] -> [Pos] -> Map.Map Span [Ir] -> [(Span, String)] -> [String]
-    genFragments []           _            _     comments = printComments comments
-    genFragments (decl:decls') []           irMap comments = let (comments', c) = printPreComment (getSpan decl) comments in
-                                                                   [c] ++ (cleanOutput $ revertLayout $ printDeclaration decl 0 irMap True $ inDecl decl comments') : (genFragments decls' [] irMap $ afterDecl decl comments')
-    genFragments (decl:decls') (frg:frgs) irMap comments = if lne decl < frg
-                                                                 then let (comments', c) = printPreComment (getSpan decl) comments in
-                                                                   [c] ++ (cleanOutput $ revertLayout $ printDeclaration decl 0 irMap True $ inDecl decl comments') : (genFragments decls' (frg:frgs) irMap $ afterDecl decl comments')
-                                                                 else "<!-- # FRAGMENT /-->" : genFragments (decl:decls') frgs irMap comments
+    genFragments :: [Declaration] -> [(Pos, String)] -> Map.Map Span [Ir] -> [(Span, String)] -> [String]
+    genFragments []           markers _ comments = printRest markers comments
+    genFragments (decl:decls') ((pos, marker):markers) irMap comments
+      | pos <= lne decl = let (comments', c) = printPreComment (Span pos pos) comments in
+                            [ c | not (null c) ] ++ marker : genFragments (decl:decls') markers irMap comments'
+    genFragments (decl:decls') markers irMap comments = let (comments', c) = printPreComment (getSpan decl) comments in
+                                                          c : (cleanOutput $ revertLayout $ printDeclaration decl 0 irMap True $ inDecl decl comments') : (genFragments decls' markers irMap $ afterDecl decl comments')
+    -- the comments and the names of the files after the last declaration, in the order of the
+    -- text; the fragment markers end with the last declaration
+    printRest [] comments = printComments comments
+    printRest ((pos, marker):markers) comments
+      | marker == fragmentMarker = printRest markers comments
+      | otherwise = let (before, after) = span (\(Span p _, _) -> p < pos) comments in
+                      printComments before ++ marker : printRest markers after
+    fragmentMarker = "<!-- # FRAGMENT /-->"
     inDecl :: Declaration -> [(Span, String)] -> [(Span, String)]
     inDecl decl comments = let s = getSpan decl in dropWhile (\x -> fst x <= s) comments
     afterDecl :: Declaration -> [(Span, String)] -> [(Span, String)]
@@ -439,27 +542,60 @@
     printComments [] = []
     printComments ((s, comment):cs') = (snd (printComment s [(s, comment)]) ++ "<br>\n"):printComments cs'
 
-iExpBasedChecks :: IModule -> (Bool, Bool)
-iExpBasedChecks iModule = (null realLiterals, null productOperators)
+-- | Whether the model has no decimal literals, no real or double literals, no product
+--   operator and no temporal operators.
+iExpBasedChecks :: IModule -> (Bool, Bool, Bool, Bool)
+iExpBasedChecks iModule = (null decimalLiterals, null realLiterals, null productOperators, null tempOperators)
   where
     iexps :: [ IExp ]
     iexps = universeOn biplate iModule
-    realLiterals = filter isIDouble iexps
+    decimalLiterals = [ e | e@(IDecimal _) <- iexps ]
+    realLiterals = [ e | e <- iexps, isRealOrDouble e ]
+    isRealOrDouble (IReal _)   = True
+    isRealOrDouble (IDouble _) = True
+    isRealOrDouble _           = False
     productOperators = filter isProductOperator iexps
-    isIDouble (IDouble _) = True
-    isIDouble (IReal _) = True
-    isIDouble _           = False
+    tempOperators = filter isTempOperator iexps
     isProductOperator (IFunExp op' _) = op' == iProdSet
     isProductOperator _               = False
 
-iClaferBasedChecks :: IModule -> Bool
-iClaferBasedChecks iModule = null $ filter hasReferenceToReal iClafers
+-- | Whether the model has no references to decimals, no references to reals or doubles, and
+--   no temporal modifiers.
+iClaferBasedChecks :: IModule -> (Bool, Bool, Bool)
+iClaferBasedChecks iModule = ( not (any (hasReferenceTo [ decimalType ]) iClafers)
+                             , not (any (hasReferenceTo [ realType, doubleType ]) iClafers)
+                             , null tempModifiers)
   where
     iClafers :: [ IClafer ]
     iClafers = universeOn biplate iModule
-    hasReferenceToReal (IClafer{_reference=(Just IReference{_ref=pexp'})}) = any (`elem` [ "real", "double" ]) $ getRefIds pexp'
-    hasReferenceToReal _                                                   = False
+    hasReferenceTo types IClafer{_reference=(Just IReference{_ref=pexp'})} = any (`elem` types) $ getRefIds pexp'
+    hasReferenceTo _     _                                                 = False
+    tempModifiers = filter hasTempModifier iClafers
 
+-- | Errors for the groups of concrete clafers whose children, including the inherited ones,
+--   cannot have as many instances as the lower bound of the group cardinality requires,
+--   e.g., @xor@ over no children. The group cardinality may be inherited or redefined.
+unsatisfiableGroups :: IModule -> [CErr Span]
+unsatisfiableGroups iModule = mapMaybe groupErr iClafers
+  where
+    iClafers :: [ IClafer ]
+    iClafers = universeOn biplate iModule
+    uidIClaferMap' = createUidIClaferMap iModule
+    groupErr c@IClafer{_cinPos, _ident, _gcard = Just IGCard{_interval = gcard'@(gMin, _)}}
+      | not (_isAbstract c) && gMin > 0 && maybe False (< gMin) maxInstances =
+          Just $ SemanticErr _cinPos $ "The group cardinality " ++ showInterval gcard' ++ " of " ++ _ident
+            ++ " cannot be satisfied: its children, including the inherited ones, can have at most "
+            ++ show (fromJust maxInstances) ++ " instances"
+      | otherwise = Nothing
+      where
+        children' = getSubclafers $ concatMap _elements $ findHierarchy getSuper uidIClaferMap' c
+        -- Nothing if a child has no upper bound
+        maxInstances = foldM addUpper 0 children'
+        addUpper n child = case _card child of
+          Just (_, m) | m >= 0 -> Just (n + m)
+          _                    -> Nothing
+    groupErr _ = Nothing
+
 -- | Generates outputs for the given IR.
 generate :: Monad m => ClaferT m (Map.Map ClaferMode CompilerResult)
 generate =
@@ -468,40 +604,57 @@
     ast' <- getAst
     (iModule, genv, au) <- getIr
     let
-      (hasNoRealLiterals, hasNoProductOperator) = iExpBasedChecks iModule
-      hasNoReferenceToReal = iClaferBasedChecks iModule
+      (hasNoDecimalLiterals, hasNoRealLiterals, hasNoProductOperator, hasNoTempOperators) = iExpBasedChecks iModule
+      (hasNoReferenceToDecimal, hasNoReferenceToReal, hasNoTempModifiers) = iClaferBasedChecks iModule
+      staticClaferSubset = hasNoTempOperators && hasNoTempModifiers
       cargs = args env
       otherTokens' = otherTokens env
       modes = mode cargs
-      stats = showStats au $ statsModule iModule
       scopes = getScopeStrategy (scope_strategy cargs) iModule
+      -- the scopes are used by the Alloy and Choco outputs only
+      scopeWarnings = if any (`elem` modes) [Alloy, AlloyLtl, Choco]
+                      then showLargeScopes (inputFiles env) $ largeReferenceScopes iModule scopes
+                      else ""
+      stats = showStats au (statsModule iModule) ++ scopeWarnings ++ showRedundantExps (inputFiles env) (redundantExps iModule)
+              ++ showNoClaferNavs (inputFiles env) (noClaferNavs ast')
+              ++ (if skip_resolver cargs then "" else showDoubleUnderscoreNames (inputFiles env) iModule)
+              ++ showFixedInitialValues (inputFiles env) (fixedInitialValues ast' iModule)
 
     return $ Map.fromList (
         -- result for Alloy
-        (if (Alloy `elem` modes)
-          then if (hasNoRealLiterals && hasNoReferenceToReal && hasNoProductOperator)
-                then
-                   let
-                      (imod,strMap) = astrModule iModule
-                      alloyCode = genModule cargs{mode = [Alloy]} (imod, genv) scopes otherTokens'
-                      addCommentStats = if no_stats cargs then const else addStats
-                   in
-                      [ (Alloy,
-                        CompilerResult {
-                         extension = "als",
-                         outputCode = addCommentStats (fst alloyCode) stats,
-                         statistics = stats,
-                         claferEnv  = env,
-                         mappingToAlloy = fromMaybe [] (Just $ snd alloyCode),
-                         stringMap = strMap,
-                         scopesList = scopes
-                        })
-                      ]
-                else [ (Alloy,
-                        NoCompilerResult {
+        (if Alloy `elem` modes
+         then if hasNoDecimalLiterals && hasNoRealLiterals && hasNoReferenceToDecimal && hasNoReferenceToReal && hasNoProductOperator
+              then
+                 let
+                    (imod,strMap) = astrModule iModule
+                    useAlloyLtlGen = not staticClaferSubset || AlloyLtl `elem` modes
+                    (genAlloyCode, alloyModes, fileExt) = if useAlloyLtlGen then (genAlloyLtlModule, [Alloy, AlloyLtl], "tmp.als") else (genModule, [Alloy], "als")
+                    -- the clafers whose UIDs cannot be Alloy names get names of their own
+                    names = alloyNames imod
+                    imodA = toAlloyNames names imod
+                    genvA = if Map.null names then genv else genv{uidClaferMap = createUidIClaferMap imodA}
+                    scopesA = [ (Map.findWithDefault u u names, s) | (u, s) <- scopes ]
+                    alloyCode = genAlloyCode cargs{mode = alloyModes} (imodA, genvA) scopesA otherTokens'
+                    addCommentStats = if no_stats cargs then const else addStats
+                 in
+                    [ (Alloy,
+                      CompilerResult {
+                       extension = fileExt,
+                       outputCode = addCommentStats (fst alloyCode) stats,
+                       statistics = stats,
+                       claferEnv  = env,
+                       mappingToAlloy = fromMaybe [] (Just $ snd alloyCode),
+                       stringMap = strMap,
+                       scopesList = scopes
+                      })
+                    ]
+              else [ (Alloy,
+                      NoCompilerResult {
                          reason = "Alloy output unavailable because the model contains: "
-                                ++ (if hasNoRealLiterals then "" else "a real number literal, ")
-                                ++ (if hasNoReferenceToReal then "" else "a reference to a real, ")
+                                ++ (if hasNoDecimalLiterals then "" else "a decimal literal, ")
+                                ++ (if hasNoRealLiterals then "" else "a real or double literal, ")
+                                ++ (if hasNoReferenceToDecimal then "" else "a reference to a decimal, ")
+                                ++ (if hasNoReferenceToReal then "" else "a reference to a real or double, ")
                                 ++ (if hasNoProductOperator then "" else "the product operator, ")
                         })
                      ]
@@ -509,16 +662,16 @@
         )
         -- result for JSON
         ++ (if (JSON `elem` modes)
-          then [ (JSON,
+            then [(JSON,
                   CompilerResult {
                    extension = "json",
                    outputCode = concat
                      [ "{"
-                     , (case gatherObjectivesAndAttributes iModule $ astModuleTrace env of
-                        Nothing         -> ""
-                        Just objectives -> "\"objectives\":" ++ (convertString $ encode $ toJSON objectives) ++ ",")
+                     , case gatherObjectivesAndAttributes iModule $ astModuleTrace env of
+                          Nothing         -> ""
+                          Just objectives -> "\"objectives\":" ++ convertString (encode $ spansInFiles (inputFiles env) $ toJSON objectives) ++ ","
                      , "\"iModule\":"
-                     , convertString $ encode $ toJSON iModule
+                     , convertString $ encode $ spansInFiles (inputFiles env) $ toJSON iModule
                      , "}"
                      ],
                    statistics = stats,
@@ -529,22 +682,31 @@
                   }) ]
           else []
         )
-        -- result for Clafer
-        ++ (if (Mode.Clafer `elem` modes)
-          then [ (Mode.Clafer,
+        -- result for Clafer: the explicit form of the model, static or temporal; chocosolver
+        -- solves the static ones
+        ++ (if Mode.Clafer `elem` modes
+          then if hasNoRealLiterals && hasNoReferenceToReal
+               then [ (Mode.Clafer,
                   CompilerResult {
                    extension = "des.cfr",
-                   outputCode = printTree $ sugarModule iModule,
+                   outputCode = fst $ genExplicitModule (iModule, genv) scopes (minint cargs, maxint cargs) (decimal_digits cargs)
+                                  (if staticClaferSubset then Nothing else Just (trace_len cargs)),
                    statistics = stats,
                    claferEnv  = env,
                    mappingToAlloy = [],
                    stringMap = Map.empty,
-                   scopesList = []
+                   scopesList = scopes
                   }) ]
+               else [ (Mode.Clafer,
+                  NoCompilerResult {
+                    reason = "Clafer output unavailable because the model contains: "
+                           ++ (if hasNoRealLiterals then "" else "a real or double literal, ")
+                           ++ (if hasNoReferenceToReal then "" else "a reference to a real or double. ")
+                  }) ]
           else []
         )
         -- result for Html
-        ++ (if (Html `elem` modes)
+        ++ (if Html `elem` modes
           then [ (Html,
                   CompilerResult {
                    extension = "html",
@@ -557,7 +719,7 @@
                   }) ]
           else []
         )
-        ++ (if (Graph `elem` modes)
+        ++ (if Graph `elem` modes
           then [ (Graph,
                   CompilerResult {
                      extension = "dot",
@@ -570,7 +732,7 @@
                   }) ]
           else []
         )
-        ++ (if (CVLGraph `elem` modes)
+        ++ (if CVLGraph `elem` modes
           then [ (CVLGraph,
                   CompilerResult {
                        extension = "cvl.dot",
@@ -584,25 +746,28 @@
           else []
         )
         -- result for Choco
-        ++ (if (Choco `elem` modes)
-          then if (hasNoRealLiterals && hasNoReferenceToReal)
-                then [ (Choco,
+        ++ (if Choco `elem` modes
+            then if hasNoRealLiterals && hasNoReferenceToReal && staticClaferSubset
+                 then [(Choco,
                         CompilerResult {
                           extension = "js",
-                          outputCode = genCModule (iModule, genv) scopes otherTokens',
+                          outputCode = genCModule (iModule, genv) scopes (minint cargs, maxint cargs) (decimal_digits cargs) otherTokens',
                           statistics = stats,
                           claferEnv  = env,
                           mappingToAlloy = [],
                           stringMap = Map.empty,
                           scopesList = scopes
-                         }) ]
-                else [ (Choco,
-                         NoCompilerResult {
-                          reason = "Choco output unavailable because the model contains: "
-                                 ++ (if hasNoRealLiterals then "" else "a real number literal, ")
-                                 ++ (if hasNoReferenceToReal then "" else "a reference to a real, ")
                          })
                       ]
+                 else [(Choco,
+                        NoCompilerResult {
+                          reason = if not staticClaferSubset
+                            then "Choco output unavailable because the model contains temporal operators"
+                            else "Choco output unavailable because the model contains: "
+                                 ++ (if hasNoRealLiterals then "" else "a real or double literal, ")
+                                 ++ (if hasNoReferenceToReal then "" else "a reference to a real or double. ")
+                        })
+                      ]
           else []
         ))
 
@@ -630,10 +795,15 @@
   _ <-liftError $ findDupModule args' iModule
   let
     au = allUnique iModule
-  let args'' = args'{skip_resolver = au && (skip_resolver args')}
-  (rTree, genv) <- liftError $ resolveModule args'' iModule
+  -- With -f, the names are the UIDs, as in an explicit model: a name that cannot be a UID is an error.
+  case nonUidNames iModule of
+    (c : _) | skip_resolver args' -> throwErr (SemanticErr (_cinPos c) $
+      "With -f (--skip-resolver), the names of the clafers are their UIDs, so they must be unique and without apostrophes, but "
+      ++ _ident c ++ " is not" :: ClaferSErr)
+    _ -> return ()
+  (rTree, genv) <- liftError $ resolveModule args' iModule
   let tTree = transModule rTree
-  return (optimizeModule args'' (tTree, genv), genv, au)
+  return (optimizeModule args' (tTree, genv), genv, au)
 
 addStats :: String -> String -> String
 addStats code stats = "/*\n" ++ stats ++ "*/\n" ++ code
@@ -645,6 +815,106 @@
           , "Goals: " ++ show ngoals
           , "Global scope: " ++ showInterval sgl
           , "Can skip name resolver: " ++ if au then "yes" else "no" ]
+
+-- | Warnings about the large scopes of references with an unbounded multiplicity, at their positions in the files
+showLargeScopes :: [ModelFile] -> [(IClafer, Integer, IClafer, Integer)] -> String
+showLargeScopes files = unlines . map showLargeScope
+  where
+  showLargeScope (clafer, scope', target, targetScope) =
+    let
+      Span (Pos l c) _ = _cinPos clafer
+      (path, l') = modelPosition files l
+      name = _ident clafer
+      reference = name ++ " -> " ++ _ident target
+      card' = fromMaybe (0, -1) $ _card clafer
+    in
+      "Warning: " ++ path ++ ":" ++ show l' ++ ":" ++ show c ++ ": the scope of " ++ reference ++ " " ++ showInterval card'
+      ++ " is " ++ show scope' ++ ", since " ++ name ++ " may point to all " ++ show targetScope ++ " " ++ _ident target ++ " in each of its parents."
+      ++ " If fewer suffice, give it an upper bound, e.g., " ++ reference ++ " " ++ show (fst card') ++ "..10, to make the instance generation faster."
+
+-- | Warnings about the expressions compared with, subtracted from or intersected with themselves, at their positions in the files
+showRedundantExps :: [ModelFile] -> [PExp] -> String
+showRedundantExps files = unlines . map showRedundantExp
+  where
+  showRedundantExp PExp{_inPos = Span (Pos l c) _, _exp = IFunExp fun _} =
+    let
+      (path, l') = modelPosition files l
+    in
+      "Warning: " ++ path ++ ":" ++ show l' ++ ":" ++ show c ++ ": '" ++ fun ++ "' is redundant because the two subexpressions are always equivalent, so it is " ++ meaning fun ++ "."
+  showRedundantExp _ = ""
+  meaning fun
+    | fun == iEq         = "always true"
+    | fun == iNeq        = "always false"
+    | fun == iDifference = "always empty"
+    | otherwise          = "the same as either subexpression"
+
+-- | The navigations from @noclafer@, e.g., @noclafer.d@, as written: the desugarer and the name
+--   resolver replace them with @noclafer@, since a navigation from the empty set is empty
+noClaferNavs :: Module -> [Span]
+noClaferNavs ast' =
+  [ s | EJoin s (ClaferId _ (Path _ [ModIdIdent _ (PosIdent (_, n))])) _ <- universeOnOf biplate uniplate ast'
+      , n == noClaferIdent ]
+
+-- | Warnings about the navigations from @noclafer@, at their positions in the files
+showNoClaferNavs :: [ModelFile] -> [Span] -> String
+showNoClaferNavs files = unlines . map showNoClaferNav
+  where
+  showNoClaferNav (Span (Pos l c) _) =
+    let
+      (path, l') = modelPosition files l
+    in
+      "Warning: " ++ path ++ ":" ++ show l' ++ ":" ++ show c ++ ": a navigation from '" ++ noClaferIdent ++ "' is redundant, since it is always empty."
+
+-- | Warnings about the names with @__@, which the compiler uses between the names of a UID
+--   (e.g., @x__size@ for the @size@ in @x@): in a full model, such a name may be the UID of
+--   another clafer, and a lookup by name, e.g., in a scope file, splits it. An explicit model
+--   (@-f@, @--explicit@) has them by design.
+showDoubleUnderscoreNames :: [ModelFile] -> IModule -> String
+showDoubleUnderscoreNames files iModule = unlines
+  [ "Warning: " ++ path ++ ":" ++ show l' ++ ":" ++ show c ++ ": the name '" ++ _ident claf
+    ++ "' contains '__', which the compiler uses in the unique names of clafers (e.g., x__size for the size in x)."
+  | claf@IClafer{_cinPos = Span (Pos l c) _} <- universeOn biplate iModule :: [IClafer]
+  , "__" `isInfixOf` _ident claf
+  , let (path, l') = modelPosition files l ]
+
+-- | The clafers with an initializer @:=@ under an inherited constant initializer @=@, e.g.,
+--   @v : Val := 2@ under @abstract Val -> integer = 2@, each with the nearest such super clafer.
+--   Inheritance is pure strengthening (kbak/clafer-semantics#164): the own initializer is added
+--   to the inherited one and does not redefine it. Since @=@ fixes the value in every state, the
+--   @:=@ repeats it or conflicts with it; the warning does not decide which (gsdlab/clafer#124).
+--   The kinds of the initializers come from the AST, since the desugarer turns them into
+--   constraints; a reference to a constant, e.g., @-> 2@, is a constant initializer.
+fixedInitialValues :: Module -> IModule -> [(IClafer, IClafer)]
+fixedInitialValues ast' iModule =
+  [ (c, s)
+  | c <- universeOn biplate iModule :: [IClafer]
+  , Map.lookup (_cinPos c) initKinds == Just False
+  , s : _ <- [ [ s | s <- drop 1 $ findHierarchy getSuper uidIClaferMap' c
+                   , _uid s /= _uid c
+                   , Map.lookup (_cinPos s) initKinds == Just True ] ] ]
+  where
+    uidIClaferMap' = createUidIClaferMap iModule
+    -- for the span of each clafer with an initializer, whether the initializer is constant
+    initKinds :: Map.Map Span Bool
+    initKinds = Map.fromList $ mapMaybe initKind (universeOnOf biplate uniplate ast' :: [Clafer])
+    initKind (Clafer s _ _ _ _ _ reference' _ init' _ _) = case init' of
+      InitSome _ (InitConstant _) _ -> Just (s, True)
+      InitSome _ (InitDefault _) _  -> Just (s, False)
+      InitEmpty _ | isJust (referenceToConstant reference') -> Just (s, True)
+      _ -> Nothing
+
+-- | Warnings about the initializers @:=@ that redefine an inherited @=@, at their positions in the files
+showFixedInitialValues :: [ModelFile] -> [(IClafer, IClafer)] -> String
+showFixedInitialValues files = unlines . map showFixedInitialValue
+  where
+  showFixedInitialValue (claf@IClafer{_cinPos = Span (Pos l c) _}, super') =
+    let
+      (path, l') = modelPosition files l
+    in
+      "Warning: " ++ path ++ ":" ++ show l' ++ ":" ++ show c ++ ": the initializer ':=' of " ++ _ident claf
+      ++ " does not redefine the initializer '=' of " ++ _ident super' ++ ", which " ++ _ident claf
+      ++ " inherits: both hold. Since '=' fixes the value in every state, the ':=' repeats an equal value,"
+      ++ " and a different value leaves no instance of " ++ _ident claf ++ "."
 
 showInterval :: (Integer, Integer) -> String
 showInterval (n, -1) = show n ++ "..*"
diff --git a/src/Language/Clafer/ClaferArgs.hs b/src/Language/Clafer/ClaferArgs.hs
--- a/src/Language/Clafer/ClaferArgs.hs
+++ b/src/Language/Clafer/ClaferArgs.hs
@@ -1,6 +1,6 @@
 {-# LANGUAGE DeriveDataTypeable #-}
 {-
- Copyright (C) 2012-2017 Kacper Bak, Jimmy Liang <http://gsd.uwaterloo.ca>
+ Copyright (C) 2012-2026 Kacper Bak, Jimmy Liang <http://gsd.uwaterloo.ca>
 
  Permission is hereby granted, free of charge, to any person obtaining a copy of
  this software and associated documentation files (the "Software"), to deal in
@@ -22,21 +22,20 @@
 -}
 {- | Command Line Arguments of the compiler.
 
-See also <http://t3-necsis.cs.uwaterloo.ca:8091/ClaferTools/CommandLineArguments a model of the arguments in Clafer>,  including constraints and examples.
+See also <https://wiselab.uwaterloo.ca/modelwiki/ClaferTools/CommandLineArguments a model of the arguments in Clafer>,  including constraints and examples.
 -}
 module Language.Clafer.ClaferArgs where
 
 import System.Console.CmdArgs
 import System.Console.CmdArgs.Explicit hiding (mode)
-import Data.List
+import Data.List ( isPrefixOf )
 import Language.Clafer.SplitJoin
 import Paths_clafer (version)
 import Data.Version (showVersion)
 
-import GetURL
 
 -- | Type of output to be generated at the end of compilation
-data ClaferMode = Alloy | JSON | Clafer | Html | Graph | CVLGraph | Choco
+data ClaferMode = AlloyLtl | Alloy | JSON | Clafer | Html | Graph | CVLGraph | Choco
   deriving (Eq, Show, Ord, Data, Typeable)
 instance Default ClaferMode where
   def = Alloy
@@ -56,6 +55,7 @@
       new_layout :: Bool,
       check_duplicates :: Bool,
       skip_resolver :: Bool,
+      explicit_model :: Bool,
       keep_unused :: Bool,
       no_stats :: Bool,
       validate :: Bool,
@@ -66,25 +66,34 @@
       show_references :: Bool,
       add_comments :: Bool,
       ecore2clafer :: Bool,
+      trace_len :: Integer,
       scope_strategy :: ScopeStrategy,
       afm :: Bool,
       meta_data :: Bool,
+      minint :: Maybe Integer,
+      maxint :: Maybe Integer,
+      decimal_digits :: Maybe Integer,
+      imports :: [FilePath],
+      import_root :: [FilePath],
+      public_imports :: Bool,
+      import_base :: String,
       file :: FilePath
     } deriving (Eq, Show, Data, Typeable)
 
 clafer :: ClaferArgs
 clafer = ClaferArgs {
-  mode                = [] &= help "Generated output type. Available CLAFERMODEs are: 'alloy' (default, Alloy 4.2); 'json' (intermediate representation of Clafer model); 'clafer' (analyzed and desugared clafer model); 'html' (original model in HTML); 'graph' (graphical representation written in DOT language); 'cvlgraph' (cvl notation representation written in DOT language); 'choco' (Choco constraint programming solver). Multiple modes can be specified at the same time, e.g., '-m alloy -m html'." &= name "m",
+  mode                = [] &= help "Generated output type. Available CLAFERMODEs are: 'alloy' (default, Alloy 6); 'json' (intermediate representation of Clafer model); 'clafer' (the explicit model, with everything written out, as Choco solves it; a temporal model with its temporal modifiers and operators, which only Alloy solves); 'html' (original model in HTML); 'graph' (graphical representation written in DOT language); 'cvlgraph' (cvl notation representation written in DOT language); 'choco' (Choco constraint programming solver). Multiple modes can be specified at the same time, e.g., '-m alloy -m html'." &= name "m",
   console_output      = def &= help "Output code on console." &= name "o",
   flatten_inheritance = def &= help "Flatten inheritance ('alloy' mode only)." &= name "i",
   timeout_analysis    = def &= help "Timeout for analysis.",
   no_layout           = def &= help "Don't resolve off-side rule layout." &= name "l",
   new_layout          = def &= help "Use new fast layout resolver (experimental)." &= name "nl",
   check_duplicates    = def &= help "Check duplicated clafer names in the entire model."  &= name "c",
-  skip_resolver       = def &= help "Skip name resolution." &= name "f",
+  skip_resolver       = def &= help "The names of the clafers are their UIDs, as in an explicit model: skip renaming them. Names must be unique; they are still resolved and checked." &= name "f",
+  explicit_model      = def &= help "The model is an explicit model, as 'clafer -m clafer' prints it, with every name a UID and every card written out, and its scopes in its scope file. Shorthand for -f -k -l --ss=none." &= explicit &= name "explicit",
   keep_unused         = def &= help "Keep uninstantated abstract clafers ('alloy' mode only)." &= name "k",
   no_stats            = def &= help "Don't print statistics." &= name "s",
-  validate            = def &= help "Validate outputs of all modes. Uses '<tooldir>/alloy4.2.jar' for Alloy models, '<tooldir>/chocosolver.jar' for Alloy models, and Clafer translator for desugared Clafer models. Use '--tooldir' to override the default location ('.') of these tools." &= name "v",
+  validate            = def &= help "Validate outputs of all modes, and exit with 1 if a tool rejects one. Uses '<tooldir>/alloy6.2.0.jar' for Alloy models, '<tooldir>/chocosolver.jar' for Choco models, dot for graphs, and clafer itself for explicit models, which must compile to themselves. Use '--tooldir' to override the default location ('.') of these tools." &= name "v",
   tooldir             = "." &= typDir &= help "Specify the tools directory ('validate' only). Default: '.' (current directory).",
   alloy_mapping       = def &= help "Generate mapping to Alloy source code ('alloy' mode only)." &= name "a",
   self_contained      = def &= help "Generate a self-contained html document ('html' mode only).",
@@ -92,67 +101,89 @@
   show_references     = def &= help "Whether the links for references should be rendered. ('html' and 'graph' modes only)." &= name "sr",
   add_comments        = def &= help "Include comments from the source file in the html output ('html' mode only).",
   ecore2clafer        = def &= help "Translate an ECore model into Clafer.",
+  trace_len           = 10 &= help "Define the maximum trace length." &= name "tl",
   scope_strategy      = def &= help "Use scope computation strategy: none or simple (default)." &= name "ss",
   afm                 = def &= help "Throws an error if the cardinality of any of the clafers is above 1." &= name "check-afm",
-  meta_data           = def &= help "Generate a 'fully qualified name'-'least-partially-qualified name'-'unique ID' map ('.cfr-map'). In Alloy and Choco modes, generate the scopes map ('.cfr-scope').",
+  meta_data           = def &= help "Generate a 'fully qualified name'-'least-partially-qualified name'-'unique ID' map ('.cfr-map'). In Alloy and Choco modes, generate the scopes map ('.cfr-scope'); in Clafer mode, the explicit model's scope file with every scope ('.des.cfr-scope').",
+  minint              = def &= help "Smallest integer value ('choco' mode only). Default: -128, chosen by chocosolver." &= typ "INT" &= explicit &= name "minint",
+  maxint              = def &= help "Largest integer value ('choco' mode only). Default: 127, chosen by chocosolver." &= typ "INT" &= explicit &= name "maxint",
+  decimal_digits      = def &= help "Number of fractional digits of decimals ('choco' mode only). Default: the most fractional digits of the model's decimal literals." &= typ "INT" &= explicit &= name "decimal-digits",
+  imports             = def &= help "Compile the model with the model in FILE (a path or an http/https URL), which is compiled before it (and only once, if imported by several files). In '//# OPTIONS', FILE is relative to the model's folder or URL; options of the imported files are combined with the model's. Can be repeated." &= typFile &= explicit &= name "import",
+  import_root         = def &= help "Allow only local imports inside DIR, after resolving '..' and symbolic links (command line only). Can be repeated; without it, any local file can be imported." &= typDir &= explicit &= name "import-root",
+  public_imports      = def &= help "Allow only URL imports from public addresses, not from loopback, private, or link-local ones, without a proxy (command line only)." &= explicit &= name "public-imports",
+  import_base         = def &= help "The URL from which the model's text was read: its imports are relative to the URL, and can only be URLs (command line only)." &= typ "URL" &= explicit &= name "import-base",
   file                = def &= args   &= typ "FILE"
  } &= summary ("Clafer " ++ showVersion Paths_clafer.version) &= program "clafer"
 
+-- | The command line of the compiler, built once: cmdArgs reads the annotations of 'clafer'
+--   (e.g., the names of the options) only the first time it is used, so the command line and
+--   the @//# OPTIONS@ of the models must be parsed with this mode.
+claferMode :: Mode (CmdArgs ClaferArgs)
+claferMode = cmdArgsMode clafer
+{-# NOINLINE claferMode #-}
+
+-- | The arguments of an empty command line (the defaults).
+claferDefaults :: ClaferArgs
+claferDefaults = either error cmdArgsValue $ process claferMode []
+
+-- | Merges the command line arguments (a1) with the options of the model (a2): an argument
+--   given on the command line takes precedence, the imports of both are kept.
 mergeArgs :: ClaferArgs -> ClaferArgs -> ClaferArgs
-mergeArgs a1 a2  = ClaferArgs (mode a1) coMergeArg
-  (mergeArg flatten_inheritance) (mergeArg timeout_analysis)
-  (mergeArg no_layout) (mergeArg new_layout)
-  (mergeArg check_duplicates) (mergeArg skip_resolver)
-  (mergeArg keep_unused) (mergeArg no_stats)
-  (mergeArg validate) toolMergeArg
-  (mergeArg alloy_mapping) (mergeArg self_contained)
-  (mergeArg add_graph) (mergeArg show_references)
-  (mergeArg add_comments) (mergeArg ecore2clafer)
-  (mergeArg scope_strategy) (mergeArg afm)
-  (mergeArg meta_data) (mergeArg file)
+mergeArgs a1 a2  = withExplicit ClaferArgs
+  { mode = mergeArg mode
+  , console_output = console_output a1 || console_output a2 || null (file a1)
+  , flatten_inheritance = mergeArg flatten_inheritance
+  , timeout_analysis = mergeArg timeout_analysis
+  , no_layout = mergeArg no_layout
+  , new_layout = mergeArg new_layout
+  , check_duplicates = mergeArg check_duplicates
+  , skip_resolver = mergeArg skip_resolver
+  , explicit_model = mergeArg explicit_model
+  , keep_unused = mergeArg keep_unused
+  , no_stats = mergeArg no_stats
+  , validate = mergeArg validate
+  , tooldir = mergeArg tooldir
+  , alloy_mapping = mergeArg alloy_mapping
+  , self_contained = mergeArg self_contained
+  , add_graph = mergeArg add_graph
+  , show_references = mergeArg show_references
+  , add_comments = mergeArg add_comments
+  , ecore2clafer = mergeArg ecore2clafer
+  , trace_len = mergeArg trace_len
+  , scope_strategy = mergeArg scope_strategy
+  , afm = mergeArg afm
+  , meta_data = mergeArg meta_data
+  , minint = mergeArg minint
+  , maxint = mergeArg maxint
+  , decimal_digits = mergeArg decimal_digits
+  , imports = imports a1 ++ filter (`notElem` imports a1) (imports a2)
+  , import_root = mergeArg import_root
+  , public_imports = mergeArg public_imports
+  , import_base = mergeArg import_base
+  , file = mergeArg file
+  }
   where
-    coMergeArg :: Bool
-    coMergeArg = if r1 then r1 else
-      if r2 then r2 else (null $ file a1)
-         where r1 = console_output a1;r2 = console_output a2
-    toolMergeArg :: String
-    toolMergeArg = if r1 /= "" then r1 else
-      if r2 /= "" then r2 else "/tools"
-      where r1 = tooldir a1;r2 = tooldir a2
-    mergeArg :: (Default a, Eq a) => (ClaferArgs -> a) -> a
-    mergeArg f = (\r -> if r /= def then r else f a2) $ f a1
-
-mainArgs :: IO (ClaferArgs, String)
-mainArgs = do
-  argsFromCmd <- cmdArgs clafer
-  model <- retrieveModelFromURL $ file argsFromCmd
-  let argsWithOpts = argsWithOPTIONS argsFromCmd model
-  -- Alloy should be the default mode but only if nothing else was specified
-  -- cannot use [ Alloy ] as the default in the definition of `clafer :: ClaferArgs` since
-  -- Alloy will always be a mode in addition to the other specified modes (it will become mandatory)
-  let argsWithDef = if null $ mode argsWithOpts
-                then argsWithOpts{mode = [ Alloy ]}
-                else argsWithOpts
-  return (argsWithDef, model)
+    -- the command line's value, unless it is the default (an option not given)
+    mergeArg :: Eq a => (ClaferArgs -> a) -> a
+    mergeArg f = if f a1 /= f claferDefaults then f a1 else f a2
 
-retrieveModelFromURL :: String -> IO String
-retrieveModelFromURL url =
-  case url of
-    "" -> getContents -- this is the pre-module system behavior
-    ('f':'i':'l':'e':':':'/':'/':n) -> readFile n
-    ('h':'t':'t':'p':':':'/':'/':_) -> getURL url
-    ('f':'t':'p':':':'/':'/':_) -> getURL url
-    n -> readFile n -- this is the pre-module system behavior
+-- | The options of an explicit model (--explicit): the names are the UIDs (-f), all clafers
+--   are kept (-k), there is no layout (-l) and no scope analysis (--ss=none), since the model
+--   and its scope file already have everything written out.
+withExplicit :: ClaferArgs -> ClaferArgs
+withExplicit args'
+  | explicit_model args' = args' { skip_resolver = True, keep_unused = True, no_layout = True, scope_strategy = None }
+  | otherwise            = args'
 
 argsWithOPTIONS :: ClaferArgs -> String -> ClaferArgs
 argsWithOPTIONS    args'         model   =
   if "//# OPTIONS " `isPrefixOf` model
   then either (const args') (mergeArgs args' . cmdArgsValue) $ -- merge wth command line arguments, which take precedence
-          process (cmdArgsMode clafer) $          -- instantiate ClaferArgs record
+          process claferMode $                    -- instantiate ClaferArgs record
             Language.Clafer.SplitJoin.splitArgs $ -- extract individual arguments
               drop 12 $                           -- strip "//# OPTIONS "
                 takeWhile (/= '\n') model         -- get first line
-  else args'
+  else withExplicit args'
 
 defaultClaferArgs :: ClaferArgs
 defaultClaferArgs = ClaferArgs
@@ -164,6 +195,7 @@
   , new_layout = False
   , check_duplicates = False
   , skip_resolver = False
+  , explicit_model = False
   , keep_unused = False
   , no_stats = False
   , validate = False
@@ -174,8 +206,16 @@
   , show_references = False
   , add_comments = False
   , ecore2clafer = False
+  , trace_len = 10
   , scope_strategy = Simple
   , afm = False
   , meta_data = False
+  , minint = Nothing
+  , maxint = Nothing
+  , decimal_digits = Nothing
+  , imports = []
+  , import_root = []
+  , public_imports = False
+  , import_base = ""
   , file = ""
   }
diff --git a/src/Language/Clafer/Common.hs b/src/Language/Clafer/Common.hs
--- a/src/Language/Clafer/Common.hs
+++ b/src/Language/Clafer/Common.hs
@@ -29,8 +29,6 @@
 import           Data.List
 import qualified Data.Map as Map
 import           Data.Maybe
-import           Data.StringMap (StringMap)
-import qualified Data.StringMap as SMap
 import           Data.Tree
 import           Prelude
 
@@ -82,6 +80,7 @@
 getRefIds (PExp _ _ _ (IFunExp{_op="**", _exps = [leftExp, rightExp]})) = getRefIds leftExp ++ getRefIds rightExp
 getRefIds (PExp _ _ _ (IInt _)) = [integerType]
 getRefIds (PExp _ _ _ (IDouble _)) = [doubleType]
+getRefIds (PExp _ _ _ (IDecimal _)) = [decimalType]
 getRefIds (PExp _ _ _ (IReal _)) = [realType]
 getRefIds (PExp _ _ _ (IStr _)) = [stringType]
 getRefIds (PExp _ _ _ (IDeclPExp{_quant = ISome})) = []
@@ -93,6 +92,9 @@
 mkPLClaferId :: Span -> CName -> Bool -> ClaferBinding -> PExp
 mkPLClaferId pos' id' isTop' bind' = pExpDefPid pos' $ IClaferId "" id' isTop' bind'
 
+pExpDefPidPos :: IExp -> PExp
+pExpDefPidPos = pExpDefPid noSpan
+
 pExpDefPid :: Span -> IExp -> PExp
 pExpDefPid = pExpDef ""
 
@@ -135,44 +137,69 @@
 -- -----------------------------------------------------------------------------
 -- UID -> IClafer map construction functions
 
-type UIDIClaferMap = StringMap IClafer
+type UIDIClaferMap = Map.Map UID IClafer
 
 createUidIClaferMap :: IModule -> UIDIClaferMap
 createUidIClaferMap    iModule  = foldl'
-    (\accumMap' claf -> SMap.insert (_uid claf) claf accumMap')
-    (SMap.singleton rootIdent rootClafer)
-    (integerClafer : intClafer : stringClafer : doubleClafer : realClafer : booleanClafer : clafer : allClafers)
+    (\accumMap' claf -> Map.insert (_uid claf) claf accumMap')
+    (Map.singleton rootIdent rootClafer)
+    (integerClafer : intClafer : stringClafer : decimalClafer : doubleClafer : realClafer : booleanClafer : clafer : allClafers)
   where
     allClafers :: [ IClafer ]
     allClafers = universeOn biplate iModule
-    rootClafer = IClafer noSpan False (Just $ IGCard False (0, -1)) rootIdent rootIdent "" Nothing Nothing (Just (1,1)) (1, 1) (_mDecls iModule)
-    integerClafer = IClafer noSpan False (Just $ IGCard False (0, -1)) integerType integerType "" (Just $ pExpDefPid noSpan $ IClaferId "" doubleType True $ Just doubleType) Nothing (Just (1,1)) (1, 1) []
-    intClafer = IClafer noSpan False (Just $ IGCard False (0, -1)) "int" "int" "" (Just $ pExpDefPid noSpan $ IClaferId "" doubleType True $ Just doubleType) Nothing (Just (1,1)) (1, 1) []
-    stringClafer = IClafer noSpan False (Just $ IGCard False (0, -1)) stringType stringType "" Nothing Nothing (Just (1,1)) (1, 1) []
-    doubleClafer = IClafer noSpan False (Just $ IGCard False (0, -1)) doubleType doubleType "" (Just $ pExpDefPid noSpan $ IClaferId "" realType True $ Just realType) Nothing (Just (1,1)) (1, 1) []
-    realClafer = IClafer noSpan False (Just $ IGCard False (0, -1)) realType realType "" Nothing Nothing (Just (1,1)) (1, 1) []
-    booleanClafer = IClafer noSpan False (Just $ IGCard False (0, -1)) booleanType booleanType "" Nothing Nothing (Just (1,1)) (1, 1) []
-    clafer = IClafer noSpan False (Just $ IGCard False (0, -1)) baseClafer baseClafer "" Nothing Nothing (Just (1,1)) (1, 1) []
+    defaultModifiers = IClaferModifiers False True True []
+    rootClafer = IClafer noSpan defaultModifiers (Just $ IGCard False (0, -1)) rootIdent rootIdent "" Nothing Nothing (Just (1,1)) (1, 1) (_mDecls iModule)
+    -- integers are decimals, decimals and doubles are reals; integers also convert to doubles (see TypeSystem)
+    integerClafer = IClafer noSpan defaultModifiers (Just $ IGCard False (0, -1)) integerType integerType "" (Just $ pExpDefPidPos $ IClaferId "" decimalType True $ GlobalBind decimalType) Nothing (Just (1,1)) (1, 1) []
+    intClafer = IClafer noSpan defaultModifiers (Just $ IGCard False (0, -1)) "int" "int" "" (Just $ pExpDefPidPos $ IClaferId "" decimalType True $ GlobalBind decimalType) Nothing (Just (1,1)) (1, 1) []
+    stringClafer = IClafer noSpan defaultModifiers (Just $ IGCard False (0, -1)) stringType stringType "" Nothing Nothing (Just (1,1)) (1, 1) []
+    decimalClafer = IClafer noSpan defaultModifiers (Just $ IGCard False (0, -1)) decimalType decimalType "" (Just $ pExpDefPidPos $ IClaferId "" realType True $ GlobalBind realType) Nothing (Just (1,1)) (1, 1) []
+    doubleClafer = IClafer noSpan defaultModifiers (Just $ IGCard False (0, -1)) doubleType doubleType "" (Just $ pExpDefPidPos $ IClaferId "" realType True $ GlobalBind realType) Nothing (Just (1,1)) (1, 1) []
+    realClafer = IClafer noSpan defaultModifiers (Just $ IGCard False (0, -1)) realType realType "" Nothing Nothing (Just (1,1)) (1, 1) []
+    booleanClafer = IClafer noSpan defaultModifiers (Just $ IGCard False (0, -1)) booleanType booleanType "" Nothing Nothing (Just (1,1)) (1, 1) []
+    clafer = IClafer noSpan defaultModifiers (Just $ IGCard False (0, -1)) baseClafer baseClafer "" Nothing Nothing (Just (1,1)) (1, 1) []
 
 -- -----------------------------------------------------------------------------
 -- functions using the UID -> IClafer map
 
 findIClafer :: UIDIClaferMap -> UID -> Maybe IClafer
-findIClafer    uidIClaferMap    uid' = SMap.lookup uid' uidIClaferMap
+findIClafer    uidIClaferMap    uid' = Map.lookup uid' uidIClaferMap
 
 isTopLevelByUID :: UIDIClaferMap -> UID -> Maybe Bool
 isTopLevelByUID    uidIClaferMap    uid' = isTopLevel <$> (findIClafer uidIClaferMap uid')
 
 -- | Finds all super clafers according to sFun
 findHierarchy :: (IClafer -> [String]) -> UIDIClaferMap -> IClafer -> [IClafer]
-findHierarchy    sFun                     uidIClaferMap    clafer   = case sFun clafer of
-  []           -> [clafer]  -- no super and no reference
-  supersOrRefs -> let
-                    superOrRefClafers = mapMaybe (findIClafer uidIClaferMap) supersOrRefs
-                  in
-                    clafer
-                    : concatMap (findHierarchy sFun uidIClaferMap) superOrRefClafers
+findHierarchy    sFun                     uidIClaferMap    clafer   = go [] clafer
+  where
+  -- A path through references can be a cycle, e.g., `abstract Person -> Bob` with
+  -- `Bob : Person`: it ends at a clafer that is already on it, which is included once, so
+  -- that an inheritance loop shows (ResolverInheritance.resolveHierarchy reports it).
+  go path c
+    | _uid c `elem` path = [c]
+    | otherwise          = case sFun c of
+        []           -> [c]  -- no super and no reference
+        supersOrRefs -> c : concatMap (go (_uid c : path)) (mapMaybe (findIClafer uidIClaferMap) supersOrRefs)
 
+-- | The set reference whose targets the instances of the clafer under one parent may not share
+--   (@->@, Juodisius et al. 5, Definition 3.4 with erratum T11), as the clafer that declares it:
+--   the clafer itself or, for a concrete clafer, the nearest super clafer with a reference
+--   (gsdlab/clafer#121). The key is local to the parent: a top-level abstract clafer has none,
+--   and its subclafers have one each, also across their parents (gsdlab/clafer#125). A clafer
+--   with at most one instance per parent needs none, and neither does a bag reference (@->>@).
+setReferenceKey :: UIDIClaferMap -> IClafer -> Maybe IClafer
+setReferenceKey uidIClaferMap' c = case (declared, _card c) of
+  (Just s, Just (lb, ub))
+    | lb > 1 || ub > 1 || ub == -1
+    , maybe False _isSet (_reference s)
+    , not (_isAbstract c && isTopLevel c) -> Just s
+  _ -> Nothing
+  where
+  declared = case _reference c of
+    Just _ -> Just c
+    Nothing | _isAbstract c -> Nothing
+            | otherwise -> listToMaybe [ s | s <- drop 1 $ findHierarchy getSuper uidIClaferMap' c, isJust (_reference s) ]
+
 -- | Finds hierarchy and transforms each element
 mapHierarchy :: (IClafer -> b)
                 -> (IClafer -> [String])
@@ -268,7 +295,9 @@
           (Just IReference{_isSet=headIsSet}, Just IReference{_isSet=superIsSet}) -> superIsSet <= headIsSet  -- set (True) implies set (True), bag (False) allows bag (False) or set (True)
           _ -> True -- covers 1) only one of them has a ref, and 2) none of them has a ref
     properTargetSubtyping NestedInheritanceMatch{_targetClafer=[targetClafer], _superClafersTarget=[superClafersTarget]}
-      = isJust $ findUIDinSupers uidIClaferMap (_uid superClafersTarget) targetClafer
+      = isJust (findUIDinSupers uidIClaferMap (_uid superClafersTarget) targetClafer)
+        -- integers are decimals in the hierarchy, and also doubles
+        || (_uid targetClafer `elem` [integerType, intType] && _uid superClafersTarget == doubleType)
     properTargetSubtyping _
       = True -- covers 1) only one of the target clafers exists, and 2) none of the target clafers exist
 
@@ -366,6 +395,27 @@
 iNot :: String
 iNot          = "!"
 
+iG :: String
+iG          = "G"
+
+iF :: String
+iF          = "F"
+
+iX :: String
+iX          = "X"
+
+iInitially :: String
+iInitially    = "initially"
+
+iFinally :: String
+iFinally    = "finally"
+
+-- | Marks the value @e@ of an initializer @x -> T := e@ that the desugarer moved from the
+--   context of the parent into the context of @x@. The name resolver resolves @e@ in the
+--   context of the parent, where it is written, and removes the marker; no other phase sees it.
+iInitValue :: String
+iInitValue  = "initvalue"
+
 iCSet :: String
 iCSet         = "#"
 
@@ -391,7 +441,7 @@
 iProdSet  = "product"
 
 unOps :: [String]
-unOps = [iNot, iCSet, iMin, iMaximum, iMinimum, iMaximize, iMinimize, iSumSet, iProdSet]
+unOps = [iNot, iCSet, iMin, iMaximum, iMinimum, iMaximize, iMinimize, iSumSet, iProdSet, iX, iF, iG, iInitially, iFinally]
 
 -- binary operators
 iIff :: String
@@ -409,8 +459,14 @@
 iAnd :: String
 iAnd          = "&&"
 
+iU :: String
+iU          = "U"
+
+iW :: String
+iW          = "W"
+
 logBinOps :: [String]
-logBinOps = [iIff, iImpl, iOr, iXor, iAnd]
+logBinOps = [iIff, iImpl, iOr, iXor, iAnd, iU, iW]
 
 iLt :: String
 iLt           = "<"
@@ -436,6 +492,19 @@
 iNin :: String
 iNin          = "not in"
 
+-- | Whether the expression has temporal operators (X, F, G, U, W, initially, finally).
+hasLtlOps :: PExp -> Bool
+hasLtlOps pexp = not $ null [ () | IFunExp op' _ <- universeOn biplate pexp :: [IExp], op' `elem` ltlOps ]
+
+ltlOps :: [String]
+ltlOps = [iW, iU, iX, iG, iF, iInitially, iFinally]
+
+ltlBinOps :: [String]
+ltlBinOps = [iW, iU]
+
+ltlUnOps :: [String]
+ltlUnOps = [iX, iG, iF, iInitially, iFinally]
+
 relGenBinOps :: [String]
 relGenBinOps = [iLt, iGt, iEq, iLte, iGte, iNeq]
 
@@ -487,6 +556,41 @@
 binOps :: [String]
 binOps = logBinOps ++ relBinOps ++ arithBinOps ++ setBinOps
 
+-- temporal keywords and property patterns
+
+temporalModifiers :: [String]
+temporalModifiers = [ "final", "initial" ]
+
+iLet :: String
+iLet = "let"
+
+propertyKeywords :: [String]
+propertyKeywords =
+  [ "never", "sometime", "lonce", "always"
+  , "must", "precede", "follow"
+  , "initially", "finally"
+  , "until", "weakuntil", "eventually", "globally", "next"
+  , "before", "after", "between", "and", "after"
+  ]
+
+-- | Whether the expression applies a temporal operator, e.g., @always@ or @X@.
+isTempOperator :: IExp -> Bool
+isTempOperator (IFunExp op' _) = op' `elem` (iLet : propertyKeywords ++ ltlOps)
+isTempOperator _               = False
+
+-- | Whether the clafer is declared @initial@ or @final@.
+hasTempModifier :: IClafer -> Bool
+hasTempModifier c = _initial (_modifiers c) || _final (_modifiers c)
+
+-- | Whether the model is dynamic: it has temporal operators or temporal modifiers.
+isDynamicModule :: IModule -> Bool
+isDynamicModule iModule = any isTempOperator iExps || any hasTempModifier iClafers
+  where
+    iExps :: [ IExp ]
+    iExps = universeOn biplate iModule
+    iClafers :: [ IClafer ]
+    iClafers = universeOn biplate iModule
+
 -- ternary operators
 iIfThenElse :: String
 iIfThenElse   = "ifthenelse"
@@ -520,8 +624,17 @@
 childrenIdent :: String
 childrenIdent = "children"
 
+-- | The empty set: no instance of any clafer, the dual of @clafer@, the union of all clafers. Like
+-- | the root, it is not declared; its type is a subtype of every clafer type (kbak/clafer-semantics#134).
+noClaferIdent :: String
+noClaferIdent = "noclafer"
+
+isNoClafer :: PExp -> Bool
+isNoClafer PExp{_exp = IClaferId{_sident = s}} = s == noClaferIdent
+isNoClafer _ = False
+
 specialNames :: [String]
-specialNames = [thisIdent, parentIdent, drefIdent, rootIdent, childrenIdent]
+specialNames = [thisIdent, parentIdent, drefIdent, rootIdent, childrenIdent, noClaferIdent]
 
 isSpecial :: String -> Bool
 isSpecial = flip elem specialNames
@@ -538,6 +651,10 @@
 realType :: String
 realType = "real"
 
+-- | Numbers with a fixed number of fractional digits, the decimal scale of the model
+decimalType :: String
+decimalType = "decimal"
+
 doubleType :: String
 doubleType = "double"
 
@@ -551,7 +668,7 @@
 modSep = "\\"
 
 primitiveTypes :: [String]
-primitiveTypes = [stringType, intType, integerType, doubleType, realType]
+primitiveTypes = [stringType, intType, integerType, decimalType, doubleType, realType]
 
 isPrimitive :: String -> Bool
 isPrimitive = flip elem primitiveTypes
@@ -567,7 +684,11 @@
   [ "if", "then", "else" ] ++ -- ternary operators
   [ "no", "not", "some", "one", "all", "disj" ] ++ -- quantifiers
   [ "opt", "mux", "or", "lone" ] ++ -- group cardinalities
-  [ "abstract", "enum" ] -- keywords
+  [ "abstract", "enum" ] ++ -- keywords
+  temporalModifiers ++ -- temporal
+  ltlOps ++ -- LTL
+  propertyKeywords ++ -- temp patterns
+  [ iLet ]
 
 data GEnv
   = GEnv
diff --git a/src/Language/Clafer/Front/AbsClafer.hs b/src/Language/Clafer/Front/AbsClafer.hs
--- a/src/Language/Clafer/Front/AbsClafer.hs
+++ b/src/Language/Clafer/Front/AbsClafer.hs
@@ -113,11 +113,11 @@
     getSpan (EnumDecl s _ _ ) = s
     getSpan (ElementDecl s _ ) = s
 data Clafer
-    = Clafer Span Abstract GCard PosIdent Super Reference Card Init Elements
+    = Clafer Span Abstract [TempModifier] GCard PosIdent Super Reference Card Init Transition Elements
   deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
 
 instance Spannable Clafer where
-    getSpan (Clafer s _ _ _ _ _ _ _ _ ) = s
+    getSpan (Clafer s _ _ _ _ _ _ _ _ _ _ ) = s
 data Constraint = Constraint Span [Exp]
   deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
 
@@ -140,6 +140,22 @@
     getSpan (GoalMaxDeprecated s _ ) = s
     getSpan (GoalMinimize s _ ) = s
     getSpan (GoalMaximize s _ ) = s
+data TempModifier
+    = Initial Span | Final Span | FinalRef Span | FinalTarget Span
+  deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
+
+instance Spannable TempModifier where
+    getSpan (Initial s ) = s
+    getSpan (Final s ) = s
+    getSpan (FinalRef s ) = s
+    getSpan (FinalTarget s ) = s
+data Transition
+    = TransitionEmpty Span | Transition Span TransArrow Exp
+  deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
+
+instance Spannable Transition where
+    getSpan (TransitionEmpty s ) = s
+    getSpan (Transition s _ _ ) = s
 data Abstract = AbstractEmpty Span | Abstract Span
   deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
 
@@ -243,16 +259,36 @@
 instance Spannable Name where
     getSpan (Path s _ ) = s
 data Exp
-    = EDeclAllDisj Span Decl Exp
+    = TransitionExp Span Exp TransArrow Exp
+    | EDeclAllDisj Span Decl Exp
     | EDeclAll Span Decl Exp
     | EDeclQuantDisj Span Quant Decl Exp
     | EDeclQuant Span Quant Decl Exp
     | EImpliesElse Span Exp Exp Exp
+    | LetExp Span VarBinding Exp
+    | TmpPatNever Span Exp PatternScope
+    | TmpPatSometime Span Exp PatternScope
+    | TmpPatLessOrOnce Span Exp PatternScope
+    | TmpPatAlways Span Exp PatternScope
+    | TmpPatPrecede Span Exp Exp PatternScope
+    | TmpPatFollow Span Exp Exp PatternScope
+    | TmpInitially Span Exp
+    | TmpFinally Span Exp
     | EIff Span Exp Exp
     | EImplies Span Exp Exp
     | EOr Span Exp Exp
     | EXor Span Exp Exp
     | EAnd Span Exp Exp
+    | LtlU Span Exp Exp
+    | TmpUntil Span Exp Exp
+    | LtlW Span Exp Exp
+    | TmpWUntil Span Exp Exp
+    | LtlF Span Exp
+    | TmpEventually Span Exp
+    | LtlG Span Exp
+    | TmpGlobally Span Exp
+    | LtlX Span Exp
+    | TmpNext Span Exp
     | ENeg Span Exp
     | ELt Span Exp Exp
     | EGt Span Exp Exp
@@ -290,16 +326,36 @@
   deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
 
 instance Spannable Exp where
+    getSpan (TransitionExp s _ _ _ ) = s
     getSpan (EDeclAllDisj s _ _ ) = s
     getSpan (EDeclAll s _ _ ) = s
     getSpan (EDeclQuantDisj s _ _ _ ) = s
     getSpan (EDeclQuant s _ _ _ ) = s
     getSpan (EImpliesElse s _ _ _ ) = s
+    getSpan (LetExp s _ _ ) = s
+    getSpan (TmpPatNever s _ _ ) = s
+    getSpan (TmpPatSometime s _ _ ) = s
+    getSpan (TmpPatLessOrOnce s _ _ ) = s
+    getSpan (TmpPatAlways s _ _ ) = s
+    getSpan (TmpPatPrecede s _ _ _ ) = s
+    getSpan (TmpPatFollow s _ _ _ ) = s
+    getSpan (TmpInitially s _ ) = s
+    getSpan (TmpFinally s _ ) = s
     getSpan (EIff s _ _ ) = s
     getSpan (EImplies s _ _ ) = s
     getSpan (EOr s _ _ ) = s
     getSpan (EXor s _ _ ) = s
     getSpan (EAnd s _ _ ) = s
+    getSpan (LtlU s _ _ ) = s
+    getSpan (TmpUntil s _ _ ) = s
+    getSpan (LtlW s _ _ ) = s
+    getSpan (TmpWUntil s _ _ ) = s
+    getSpan (LtlF s _ ) = s
+    getSpan (TmpEventually s _ ) = s
+    getSpan (LtlG s _ ) = s
+    getSpan (TmpGlobally s _ ) = s
+    getSpan (LtlX s _ ) = s
+    getSpan (TmpNext s _ ) = s
     getSpan (ENeg s _ ) = s
     getSpan (ELt s _ _ ) = s
     getSpan (EGt s _ _ ) = s
@@ -334,11 +390,47 @@
     getSpan (EDouble s _ ) = s
     getSpan (EReal s _ ) = s
     getSpan (EStr s _ ) = s
+data TransGuard = TransGuard Span Exp
+  deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
+
+instance Spannable TransGuard where
+    getSpan (TransGuard s _ ) = s
+data TransArrow
+    = SyncTransArrow Span
+    | GuardedSyncTransArrow Span TransGuard
+    | NextTransArrow Span
+    | GuardedNextTransArrow Span TransGuard
+  deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
+
+instance Spannable TransArrow where
+    getSpan (SyncTransArrow s ) = s
+    getSpan (GuardedSyncTransArrow s _ ) = s
+    getSpan (NextTransArrow s ) = s
+    getSpan (GuardedNextTransArrow s _ ) = s
+data PatternScope
+    = PatScopeBefore Span Exp
+    | PatScopeAfter Span Exp
+    | PatScopeBetweenAnd Span Exp Exp
+    | PatScopeAfterUntil Span Exp Exp
+    | PatScopeEmpty Span
+  deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
+
+instance Spannable PatternScope where
+    getSpan (PatScopeBefore s _ ) = s
+    getSpan (PatScopeAfter s _ ) = s
+    getSpan (PatScopeBetweenAnd s _ _ ) = s
+    getSpan (PatScopeAfterUntil s _ _ ) = s
+    getSpan (PatScopeEmpty s ) = s
 data Decl = Decl Span [LocId] Exp
   deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
 
 instance Spannable Decl where
     getSpan (Decl s _ _ ) = s
+data VarBinding = VarBinding Span LocId Exp
+  deriving (Eq, Ord, Show, Read, Data, Typeable, Generic)
+
+instance Spannable VarBinding where
+    getSpan (VarBinding s _ _ ) = s
 data Quant
     = QuantNo Span
     | QuantNot Span
diff --git a/src/Language/Clafer/Front/ErrM.hs b/src/Language/Clafer/Front/ErrM.hs
--- a/src/Language/Clafer/Front/ErrM.hs
+++ b/src/Language/Clafer/Front/ErrM.hs
@@ -17,9 +17,11 @@
 
 instance Monad Err where
   return      = pure
-  fail        = Bad noPos
   Ok a  >>= f = f a
   Bad p s >>= _ = Bad p s
+
+instance MonadFail Err where
+  fail        = Bad noPos
 
 instance Applicative Err where
   pure = Ok
diff --git a/src/Language/Clafer/Front/LayoutResolver.hs b/src/Language/Clafer/Front/LayoutResolver.hs
--- a/src/Language/Clafer/Front/LayoutResolver.hs
+++ b/src/Language/Clafer/Front/LayoutResolver.hs
@@ -24,11 +24,14 @@
 module Language.Clafer.Front.LayoutResolver where
 
 -- very simple layout resolver
+import Control.Monad
 import Control.Monad.State
 import Data.Functor.Identity (Identity)
 import Language.ClaferT
 
 import Language.Clafer.Front.LexClafer
+import Language.Clafer.Front.ParClafer (layoutSeparator, isLayoutSeparator)
+import qualified Data.Map as Map
 import Data.Maybe
 
 data LayEnv = LayEnv {
@@ -62,9 +65,25 @@
 layoutClose :: String
 layoutClose = "}"
 
-resolveLayout :: (Monad m) => [Token] -> ClaferT m  [Token]
-resolveLayout xs = addNewLines xs >>= (resolve (LEnv [1] Nothing)) >>= adjust
+-- | Resolves the layout of the parseable tokens. The other tokens (comments and escape blocks) do not
+-- | count: a line which starts with them is indented as if they were not there, at the column where
+-- | the first of them starts, e.g., @/*history*/ xor on@ at the column of @/*@. Token positions are unchanged.
+resolveLayout :: (Monad m) => [Token] -- ^ the other tokens
+                           -> [Token] -- ^ the parseable tokens
+                           -> ClaferT m [Token]
+resolveLayout otherTokens' xs = addNewLines (layoutColumn otherTokens') xs >>= (resolve (LEnv [1] Nothing)) >>= adjust
 
+-- | The column which determines the indentation of a line starting with the given token:
+-- | the column of the first other token which ends on the token's line before it, if any.
+layoutColumn :: [Token] -> Token -> Int
+layoutColumn otherTokens' t = case Map.lookup (line t) firstOnLine of
+  Just (l, c) | (l, c) < (line t, column t) -> c
+  _                                         -> column t
+  where
+  -- the start of the first other token ending on each line
+  firstOnLine = Map.fromListWith min [ (endLine o, (line o, column o)) | o <- otherTokens' ]
+  endLine o = line o + length (filter (== '\n') $ prToken o)
+
 resolve :: (Monad m) => LEnv -> [ExToken] -> ClaferT m [Token]
 resolve (LEnv st _) [] = return $ replicate (length st - 1) dedent
 resolve (LEnv st _) ((NewLine lastNl):ts) = resolve (LEnv st (Just lastNl)) ts
@@ -77,10 +96,10 @@
     t' >>=  return . (indent:) . (:r)
   | isJust lastNl && newLev == head st = do
     r <- resolve (LEnv st Nothing) ts
-    t' >>= return . (:r)
+    t' >>= return . (layoutSeparator:) . (:r)
   | isJust lastNl = do
     r <- resolve (LEnv st' Nothing) ts
-    t' >>= return . (replicate (length st - length st') dedent ++) . (:r)
+    t' >>= return . (replicate (length st - length st') dedent ++) . (layoutSeparator:) . (:r)
   | otherwise = do
     r <- resolve env ts
     t' >>= return . (:r)
@@ -174,29 +193,30 @@
 tokenLength t = length $ prToken t
 
 -- data ExToken = NewLine (Int, Int) | ExToken Token
-addNewLines :: (Monad m) => [Token] -> ClaferT m [ExToken]
-addNewLines []    = return []
-addNewLines ts@(t:_) = addNewLines' (if isBracketOpen t then 1 else 0) ts
+addNewLines :: (Monad m) => (Token -> Int) -- ^ the column which determines the indentation of a line starting with the token
+                         -> [Token] -> ClaferT m [ExToken]
+addNewLines _         []       = return []
+addNewLines layoutCol ts@(t:_) = addNewLines' layoutCol (if isBracketOpen t then 1 else 0) ts
 
-addNewLines' :: (Monad m) => Int -> [Token] -> ClaferT m [ExToken]
-addNewLines' _ []                     = return []
-addNewLines' 0 (t:[])                 = return [ExToken t]
-addNewLines' 1 (t:[])                 = return [ExToken t]
-addNewLines' _ ((PT (Pn z x y) t):[]) = throwErr $ ParseErr (ErrPos z fPos fPos) $ "']' bracket missing for (" ++ show t ++ ")"
+addNewLines' :: (Monad m) => (Token -> Int) -> Int -> [Token] -> ClaferT m [ExToken]
+addNewLines' _ _ []                     = return []
+addNewLines' _ 0 (t:[])                 = return [ExToken t]
+addNewLines' _ 1 (t:[])                 = return [ExToken t]
+addNewLines' _ _ ((PT (Pn z x y) t):[]) = throwErr $ ParseErr (ErrPos z fPos fPos) $ "']' bracket missing for (" ++ show t ++ ")"
   where
     fPos = (Pos (fromIntegral x) (fromIntegral y))
-addNewLines' n (t0:t1:ts)
+addNewLines' layoutCol n (t0:t1:ts)
   | isNewLine t0 t1 && isBracketOpen t1 =
-    addNewLines' (n + 1) (t1:ts) >>= (return . (ExToken t0:) . (NewLine (column t1, n):))
+    addNewLines' layoutCol (n + 1) (t1:ts) >>= (return . (ExToken t0:) . (NewLine (layoutCol t1, n):))
   | isNewLine t0 t1 && isBracketClose t1 =
-    addNewLines' (n - 1) (t1:ts) >>= (return . (ExToken t0:) . (NewLine (column t1, n):))
+    addNewLines' layoutCol (n - 1) (t1:ts) >>= (return . (ExToken t0:) . (NewLine (layoutCol t1, n):))
   | isLayoutOpen t1  || isBracketOpen t1 =
-    addNewLines' (n + 1) (t1:ts) >>= (return . (ExToken t0:))
+    addNewLines' layoutCol (n + 1) (t1:ts) >>= (return . (ExToken t0:))
   | isLayoutClose t1 || isBracketClose t1 =
-    addNewLines' (n - 1) (t1:ts) >>= (return . (ExToken t0:))
-  | isNewLine t0 t1  = addNewLines' n (t1:ts) >>= (return . (ExToken t0:) . (NewLine (column t1, n):))
-  | otherwise        = addNewLines' n (t1:ts) >>= (return . (ExToken t0:))
-addNewLines' _ tokens' = throwErr (ClaferErr ("[bug] LayoutResolver.addNewLines': invalid argument:" ++ show tokens') :: CErr Span) -- This should never happen!
+    addNewLines' layoutCol (n - 1) (t1:ts) >>= (return . (ExToken t0:))
+  | isNewLine t0 t1  = addNewLines' layoutCol n (t1:ts) >>= (return . (ExToken t0:) . (NewLine (layoutCol t1, n):))
+  | otherwise        = addNewLines' layoutCol n (t1:ts) >>= (return . (ExToken t0:))
+addNewLines' _ _ tokens' = throwErr (ClaferErr ("[bug] LayoutResolver.addNewLines': invalid argument:" ++ show tokens') :: CErr Span) -- This should never happen!
 
 
 adjust :: (Monad m) => [Token] -> ClaferT m [Token]
@@ -207,9 +227,14 @@
 updToken :: (Monad m) => [Token] -> ClaferT m [Token]
 updToken (t0:t1:ts)
   | isLayoutOpen t1 || isLayoutClose t1 = addToken (nextPos t0) sym ts
+  -- the separator of sibling lines has no characters, so the tokens after it keep their positions
+  | isLayoutSeparator t1 = return (PT (nextPos t0) sepTok : ts)
   | otherwise = return (t1:ts)
   where
   sym = if isLayoutOpen t1 then "{" else "}"
+  sepTok = case layoutSeparator of
+    PT _ t -> t
+    Err _    -> error "LayoutResolver.updToken: the layout separator is not a token"
   -- | Get the position immediately to the right of the given token.
   nextPos :: Token -> Position
   nextPos t = Pn (g + s) l (c + s + 1)
diff --git a/src/Language/Clafer/Front/LexClafer.hs b/src/Language/Clafer/Front/LexClafer.hs
--- a/src/Language/Clafer/Front/LexClafer.hs
+++ b/src/Language/Clafer/Front/LexClafer.hs
@@ -1,7 +1,10 @@
-{-# OPTIONS_GHC -fno-warn-unused-binds -fno-warn-missing-signatures #-}
-{-# LANGUAGE CPP,MagicHash #-}
+{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
+{-# OPTIONS_GHC -fno-warn-tabs #-}
+{-# OPTIONS_GHC -fno-warn-unused-binds #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE MagicHash #-}
 {-# LINE 3 "Language/Clafer/Front/LexClafer.x" #-}
-
 {-# OPTIONS -fno-warn-incomplete-patterns #-}
 {-# OPTIONS_GHC -w #-}
 module Language.Clafer.Front.LexClafer where
@@ -10,43 +13,373 @@
 
 import qualified Data.Bits
 import Data.Word (Word8)
-
-#if __GLASGOW_HASKELL__ >= 603
-#include "ghcconfig.h"
-#elif defined(__GLASGOW_HASKELL__)
-#include "config.h"
-#endif
-#if __GLASGOW_HASKELL__ >= 503
-import Data.Array
 import Data.Char (ord)
+#include "ghcconfig.h"
+import qualified Data.Array
+import qualified Data.Char
 import Data.Array.Base (unsafeAt)
-#else
-import Array
-import Char (ord)
-#endif
-#if __GLASGOW_HASKELL__ >= 503
-import GHC.Exts
-#else
-import GlaExts
-#endif
+import GHC.Exts (Addr#,Int#,Int(I#),(*#),(+#),(-#),(==#),(>=#),indexCharOffAddr#,indexInt16OffAddr#,indexInt32OffAddr#,int2Word#,narrow16Int#,narrow32Int#,negateInt#,or#,ord#,uncheckedShiftL#,word2Int#)
+import qualified GHC.Exts
 alex_tab_size :: Int
 alex_tab_size = 8
 alex_base :: AlexAddr
-alex_base = AlexA# "\xf8\xff\xff\xff\x4c\x00\x00\x00\xef\x00\x00\x00\x92\x01\x00\x00\x35\x02\x00\x00\xd8\x02\x00\x00\x8d\xff\xff\xff\x98\xff\xff\xff\x99\xff\xff\xff\xa6\xff\xff\xff\x9b\xff\xff\xff\xa3\xff\xff\xff\xa0\xff\xff\xff\xa1\xff\xff\xff\xd8\x03\x00\x00\x92\xff\xff\xff\x98\x03\x00\x00\x98\x04\x00\x00\x93\xff\xff\xff\x58\x04\x00\x00\x58\x05\x00\x00\x18\x05\x00\x00\x9c\x05\x00\x00\x20\x06\x00\x00\xa4\x06\x00\x00\x28\x07\x00\x00\xfe\x07\x00\x00\xfe\x08\x00\x00\x34\x00\x00\x00\x69\x07\x00\x00\x7e\x09\x00\x00\x3e\x09\x00\x00\xbe\x09\x00\x00\x33\x0a\x00\x00\x4d\x00\x00\x00\x61\x00\x00\x00\x79\x00\x00\x00\x7e\x00\x00\x00\xe5\xff\xff\xff\x4f\x00\x00\x00\xd4\xff\xff\xff\xd5\xff\xff\xff\xed\xff\xff\xff\xb3\xff\xff\xff\x00\x00\x00\x00\xbc\xff\xff\xff\xd7\xff\xff\xff\x3d\x00\x00\x00\xf1\xff\xff\xff\x2d\x00\x00\x00\x52\x00\x00\x00\x8c\x00\x00\x00\x1d\x01\x00\x00\x03\x0b\x00\x00\x00\x00\x00\x00\x28\x0b\x00\x00\x79\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\x0b\x00\x00\x00\x00\x00\x00\x81\x0c\x00\x00"#
+alex_base = AlexA#
+  "\xf8\xff\xff\xff\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\xb6\xff\xff\xff\xe0\xff\xff\xff\xdc\xff\xff\xff\x0f\x01\x00\x00\xce\xff\xff\xff\x8d\xff\xff\xff\x00\x00\x00\x00\xcf\xff\xff\xff\x90\xff\xff\xff\x6b\x01\x00\x00\x6f\x01\x00\x00\x12\x02\x00\x00\x96\x02\x00\x00\x39\x03\x00\x00\xbd\x03\x00\x00\x10\x01\x00\x00\xab\xff\xff\xff\xa0\xff\xff\xff\xa1\xff\xff\xff\xa2\xff\xff\xff\x99\xff\xff\xff\xa7\xff\xff\xff\xbd\x04\x00\x00\x3d\x05\x00\x00\x98\xff\xff\xff\xa9\xff\xff\xff\xae\xff\xff\xff\x9b\x05\x00\x00\x9c\x05\x00\x00\x9c\x06\x00\x00\xa0\x06\x00\x00\x76\x07\x00\x00\x76\x08\x00\x00\xe1\x06\x00\x00\x36\x08\x00\x00\x77\x08\x00\x00\x1a\x09\x00\x00\x9e\x09\x00\x00\x41\x0a\x00\x00\x17\x0b\x00\x00\x45\x01\x00\x00\xea\xff\xff\xff\x56\x00\x00\x00\xde\xff\xff\xff\x19\x00\x00\x00\xe2\xff\xff\xff\xfa\xff\xff\xff\x88\x00\x00\x00\x90\x00\x00\x00\x29\x01\x00\x00\x2b\x01\x00\x00\x40\x02\x00\x00\x4a\x02\x00\x00\x8f\x05\x00\x00\x54\x02\x00\x00\x00\x00\x00\x00\xf0\x0b\x00\x00\xc7\x0a\x00\x00\x41\x0c\x00\x00\xab\x0b\x00\x00\x00\x00\x00\x00"#
 
 alex_table :: AlexAddr
-alex_table = AlexA# "\x00\x00\x25\x00\x25\x00\x25\x00\x25\x00\x25\x00\x12\x00\x0f\x00\x06\x00\x07\x00\x09\x00\x0a\x00\x0d\x00\x08\x00\x17\x00\x19\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x0c\x00\x2c\x00\x0b\x00\x1a\x00\x25\x00\x28\x00\x21\x00\x2c\x00\x38\x00\x2c\x00\x32\x00\x2c\x00\x2c\x00\x2c\x00\x31\x00\x26\x00\x2c\x00\x27\x00\x30\x00\x2a\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x29\x00\x2c\x00\x2f\x00\x2e\x00\x29\x00\x2c\x00\x2c\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x2b\x00\x2c\x00\x2c\x00\x21\x00\x2c\x00\x2c\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x2c\x00\x2d\x00\x2c\x00\x01\x00\x2c\x00\x2c\x00\x2c\x00\x2e\x00\x39\x00\x2c\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x25\x00\x25\x00\x25\x00\x25\x00\x25\x00\x00\x00\x2e\x00\x24\x00\x00\x00\x21\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x00\x00\x00\x00\x00\x00\x25\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x00\x20\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x03\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x36\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x00\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\xff\xff\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
+alex_table = AlexA#
+  "\x00\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x0a\x00\x0a\x00\x0a\x00\x0a\x00\x0a\x00\x2f\x00\x0e\x00\x2f\x00\x17\x00\x18\x00\x14\x00\x0c\x00\x1c\x00\x1d\x00\x22\x00\x15\x00\x16\x00\x0b\x00\x2c\x00\x31\x00\x20\x00\x0a\x00\x0a\x00\x0a\x00\x05\x00\x0a\x00\x0a\x00\x0a\x00\x34\x00\x06\x00\x0a\x00\x07\x00\x33\x00\x35\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x30\x00\x0a\x00\x08\x00\x2f\x00\x30\x00\x0a\x00\x2f\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x2e\x00\x0a\x00\x2d\x00\x0a\x00\x0a\x00\x0a\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x0a\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x19\x00\x2a\x00\x1e\x00\x0a\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\x38\x00\x00\x00\x00\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x3a\x00\x00\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x36\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x03\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x10\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x3b\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x20\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x00\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x00\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\xff\xff\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x3f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
 
 alex_check :: AlexAddr
-alex_check = AlexA# "\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x79\x00\x6f\x00\x6f\x00\x63\x00\x6f\x00\x68\x00\x6c\x00\x6c\x00\x7c\x00\x7c\x00\x2b\x00\x3d\x00\x3d\x00\x3e\x00\x61\x00\x3e\x00\x63\x00\x2a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x2f\x00\x25\x00\x26\x00\x2e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x7c\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x22\x00\x2a\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x2a\x00\x3a\x00\x26\x00\x3c\x00\x3d\x00\x2f\x00\x2d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x3e\x00\x2d\x00\xff\xff\x5c\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xc3\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x5d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x22\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xff\xff\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x0a\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00"#
+alex_check = AlexA#
+  "\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x26\x00\x2b\x00\x3a\x00\x7c\x00\x3c\x00\x3d\x00\x7c\x00\x3e\x00\x63\x00\x6f\x00\x6f\x00\x6f\x00\x79\x00\x6c\x00\x7c\x00\x6c\x00\x68\x00\x2d\x00\x20\x00\x21\x00\x22\x00\x23\x00\x3e\x00\x25\x00\x26\x00\x3d\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x3e\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x3d\x00\x3e\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2e\x00\x61\x00\x7c\x00\x63\x00\x2a\x00\xc3\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2d\x00\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x3e\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x5d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x22\x00\x22\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\x5c\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\xff\xff\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xff\xff\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x0a\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00"#
 
 alex_deflt :: AlexAddr
-alex_deflt = AlexA# "\xff\xff\x1a\x00\x19\x00\x19\x00\x17\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\xff\xff\x17\x00\x19\x00\xff\xff\x19\x00\x1a\x00\x1a\x00\x17\x00\x17\x00\x19\x00\x19\x00\x1a\x00\x21\x00\xff\xff\x21\x00\x38\x00\x38\x00\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x19\x00\xff\xff\x17\x00"#
+alex_deflt = AlexA#
+  "\xff\xff\xff\xff\x22\x00\xff\xff\x0e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x00\x0e\x00\x0e\x00\x0e\x00\x0e\x00\x0e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x20\x00\x22\x00\x23\x00\x23\x00\x22\x00\x23\x00\x20\x00\x22\x00\x22\x00\x22\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3e\x00\x3e\x00\xff\xff"#
 
-alex_accept = listArray (0::Int,61) [AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccSkip,AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_1),AlexAcc (alex_action_2),AlexAcc (alex_action_3),AlexAcc (alex_action_4),AlexAcc (alex_action_5),AlexAcc (alex_action_6),AlexAcc (alex_action_7),AlexAcc (alex_action_8),AlexAcc (alex_action_9),AlexAcc (alex_action_9),AlexAcc (alex_action_10),AlexAcc (alex_action_10)]
-{-# LINE 45 "Language/Clafer/Front/LexClafer.x" #-}
+alex_accept = Data.Array.listArray (0 :: Int, 64)
+  [ AlexAccNone
+  , AlexAcc 25
+  , AlexAcc 24
+  , AlexAcc 23
+  , AlexAccNone
+  , AlexAcc 22
+  , AlexAcc 21
+  , AlexAcc 20
+  , AlexAcc 19
+  , AlexAcc 18
+  , AlexAcc 17
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAcc 16
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccNone
+  , AlexAccSkip
+  , AlexAcc 15
+  , AlexAcc 14
+  , AlexAcc 13
+  , AlexAcc 12
+  , AlexAcc 11
+  , AlexAcc 10
+  , AlexAcc 9
+  , AlexAcc 8
+  , AlexAcc 7
+  , AlexAcc 6
+  , AlexAcc 5
+  , AlexAccNone
+  , AlexAcc 4
+  , AlexAccNone
+  , AlexAcc 3
+  , AlexAcc 2
+  , AlexAccNone
+  , AlexAcc 1
+  , AlexAccNone
+  , AlexAcc 0
+  ]
 
+alex_actions = Data.Array.array (0 :: Int, 26)
+  [ (25,alex_action_9)
+  , (24,alex_action_9)
+  , (23,alex_action_10)
+  , (22,alex_action_1)
+  , (21,alex_action_1)
+  , (20,alex_action_1)
+  , (19,alex_action_1)
+  , (18,alex_action_1)
+  , (17,alex_action_1)
+  , (16,alex_action_10)
+  , (15,alex_action_1)
+  , (14,alex_action_1)
+  , (13,alex_action_1)
+  , (12,alex_action_1)
+  , (11,alex_action_1)
+  , (10,alex_action_1)
+  , (9,alex_action_1)
+  , (8,alex_action_1)
+  , (7,alex_action_1)
+  , (6,alex_action_2)
+  , (5,alex_action_3)
+  , (4,alex_action_4)
+  , (3,alex_action_5)
+  , (2,alex_action_6)
+  , (1,alex_action_7)
+  , (0,alex_action_8)
+  ]
 
+alex_action_1 = tok (\p s -> PT p (eitherResIdent (TV . share) s))
+alex_action_2 = tok (\p s -> PT p (eitherResIdent (T_PosInteger . share) s))
+alex_action_3 = tok (\p s -> PT p (eitherResIdent (T_PosDouble . share) s))
+alex_action_4 = tok (\p s -> PT p (eitherResIdent (T_PosReal . share) s))
+alex_action_5 = tok (\p s -> PT p (eitherResIdent (T_PosString . share) s))
+alex_action_6 = tok (\p s -> PT p (eitherResIdent (T_PosIdent . share) s))
+alex_action_7 = tok (\p s -> PT p (eitherResIdent (T_PosLineComment . share) s))
+alex_action_8 = tok (\p s -> PT p (eitherResIdent (T_PosBlockComment . share) s))
+alex_action_9 = tok (\p s -> PT p (eitherResIdent (T_PosAlloy . share) s))
+alex_action_10 = tok (\p s -> PT p (eitherResIdent (T_PosChoco . share) s))
+alex_action_11 = tok (\p s -> PT p (eitherResIdent (TV . share) s))
+
+#define ALEX_GHC 1
+#define ALEX_NOPRED 1
+-- -----------------------------------------------------------------------------
+-- ALEX TEMPLATE
+--
+-- This code is in the PUBLIC DOMAIN; you may copy it freely and use
+-- it for any purpose whatsoever.
+
+-- -----------------------------------------------------------------------------
+-- INTERNALS and main scanner engine
+
+#ifdef ALEX_GHC
+#  define ILIT(n) n#
+#  define IBOX(n) (I# (n))
+#  define FAST_INT Int#
+-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
+#  if __GLASGOW_HASKELL__ > 706
+#    define CMP_GEQ(n,m) (((n) >=# (m)) :: Int#)
+#    define CMP_EQ(n,m) (((n) ==# (m)) :: Int#)
+#    define CMP_MKBOOL(x) ((GHC.Exts.tagToEnum# (x)) :: Bool)
+#  else
+#    define CMP_GEQ(n,m) (((n) >= (m)) :: Bool)
+#    define CMP_EQ(n,m) (((n) == (m)) :: Bool)
+#    define CMP_MKBOOL(x) ((x) :: Bool)
+#  endif
+#  define GTE(n,m) CMP_MKBOOL(CMP_GEQ(n,m))
+#  define EQ(n,m) CMP_MKBOOL(CMP_EQ(n,m))
+#  define PLUS(n,m) (n +# m)
+#  define MINUS(n,m) (n -# m)
+#  define TIMES(n,m) (n *# m)
+#  define NEGATE(n) (negateInt# (n))
+#  define IF_GHC(x) (x)
+#else
+#  define ILIT(n) (n)
+#  define IBOX(n) (n)
+#  define FAST_INT Int
+#  define GTE(n,m) (n >= m)
+#  define EQ(n,m) (n == m)
+#  define PLUS(n,m) (n + m)
+#  define MINUS(n,m) (n - m)
+#  define TIMES(n,m) (n * m)
+#  define NEGATE(n) (negate (n))
+#  define IF_GHC(x)
+#endif
+
+#ifdef ALEX_GHC
+data AlexAddr = AlexA# Addr#
+-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
+
+{-# INLINE alexIndexInt16OffAddr #-}
+alexIndexInt16OffAddr :: AlexAddr -> Int# -> Int#
+alexIndexInt16OffAddr (AlexA# arr) off =
+#if __GLASGOW_HASKELL__ >= 901
+  GHC.Exts.int16ToInt# -- qualified import because it doesn't exist on older GHC's
+#endif
+#ifdef WORDS_BIGENDIAN
+  (GHC.Exts.word16ToInt16# (GHC.Exts.wordToWord16# (GHC.Exts.byteSwap16# (GHC.Exts.word16ToWord# (GHC.Exts.int16ToWord16#
+#endif
+  (indexInt16OffAddr# arr off)
+#ifdef WORDS_BIGENDIAN
+  )))))
+#endif
+#else
+alexIndexInt16OffAddr = (Data.Array.!)
+#endif
+
+#ifdef ALEX_GHC
+{-# INLINE alexIndexInt32OffAddr #-}
+alexIndexInt32OffAddr :: AlexAddr -> Int# -> Int#
+alexIndexInt32OffAddr (AlexA# arr) off =
+#if __GLASGOW_HASKELL__ >= 901
+  GHC.Exts.int32ToInt# -- qualified import because it doesn't exist on older GHC's
+#endif
+#ifdef WORDS_BIGENDIAN
+  (GHC.Exts.word32ToInt32# (GHC.Exts.wordToWord32# (GHC.Exts.byteSwap32# (GHC.Exts.word32ToWord# (GHC.Exts.int32ToWord32#
+#endif
+  (indexInt32OffAddr# arr off)
+#ifdef WORDS_BIGENDIAN
+  )))))
+#endif
+#else
+alexIndexInt32OffAddr = (Data.Array.!)
+#endif
+
+#ifdef ALEX_GHC
+-- GHC >= 503, unsafeAt is available from Data.Array.Base.
+quickIndex = unsafeAt
+#else
+quickIndex = (Data.Array.!)
+#endif
+
+-- -----------------------------------------------------------------------------
+-- Main lexing routines
+
+data AlexReturn a
+  = AlexEOF
+  | AlexError  !AlexInput
+  | AlexSkip   !AlexInput !Int
+  | AlexToken  !AlexInput !Int a
+
+-- alexScan :: AlexInput -> StartCode -> AlexReturn a
+alexScan input__ IBOX(sc)
+  = alexScanUser (error "alex rule requiring context was invoked by alexScan; use alexScanUser instead?") input__ IBOX(sc)
+
+-- If the generated alexScan/alexScanUser functions are called multiple times
+-- in the same file, alexScanUser gets broken out into a separate function and
+-- increases memory usage. Make sure GHC inlines this function and optimizes it.
+{-# INLINE alexScanUser #-}
+
+alexScanUser user__ input__ IBOX(sc)
+  = case alex_scan_tkn user__ input__ ILIT(0) input__ sc AlexNone of
+  (AlexNone, input__') ->
+    case alexGetByte input__ of
+      Nothing ->
+#ifdef ALEX_DEBUG
+                                   Debug.Trace.trace ("End of input.") $
+#endif
+                                   AlexEOF
+      Just _ ->
+#ifdef ALEX_DEBUG
+                                   Debug.Trace.trace ("Error.") $
+#endif
+                                   AlexError input__'
+
+  (AlexLastSkip input__'' len, _) ->
+#ifdef ALEX_DEBUG
+    Debug.Trace.trace ("Skipping.") $
+#endif
+    AlexSkip input__'' len
+
+  (AlexLastAcc k input__''' len, _) ->
+#ifdef ALEX_DEBUG
+    Debug.Trace.trace ("Accept.") $
+#endif
+    AlexToken input__''' len ((Data.Array.!) alex_actions k)
+
+
+-- Push the input through the DFA, remembering the most recent accepting
+-- state it encountered.
+
+alex_scan_tkn user__ orig_input len input__ s last_acc =
+  input__ `seq` -- strict in the input
+  let
+  new_acc = (check_accs (alex_accept `quickIndex` IBOX(s)))
+  in
+  new_acc `seq`
+  case alexGetByte input__ of
+     Nothing -> (new_acc, input__)
+     Just (c, new_input) ->
+#ifdef ALEX_DEBUG
+      Debug.Trace.trace ("State: " ++ show IBOX(s) ++ ", char: " ++ show c ++ " " ++ (show . Data.Char.chr . fromIntegral) c) $
+#endif
+      case fromIntegral c of { IBOX(ord_c) ->
+        let
+                base   = alexIndexInt32OffAddr alex_base s
+                offset = PLUS(base,ord_c)
+
+                new_s = if GTE(offset,ILIT(0))
+                          && let check  = alexIndexInt16OffAddr alex_check offset
+                             in  EQ(check,ord_c)
+                          then alexIndexInt16OffAddr alex_table offset
+                          else alexIndexInt16OffAddr alex_deflt s
+        in
+        case new_s of
+            ILIT(-1) -> (new_acc, input__)
+                -- on an error, we want to keep the input *before* the
+                -- character that failed, not after.
+            _ -> alex_scan_tkn user__ orig_input
+#ifdef ALEX_LATIN1
+                   PLUS(len,ILIT(1))
+                   -- issue 119: in the latin1 encoding, *each* byte is one character
+#else
+                   (if c < 0x80 || c >= 0xC0 then PLUS(len,ILIT(1)) else len)
+                   -- note that the length is increased ONLY if this is the 1st byte in a char encoding)
+#endif
+                   new_input new_s new_acc
+      }
+  where
+        check_accs (AlexAccNone) = last_acc
+        check_accs (AlexAcc a  ) = AlexLastAcc a input__ IBOX(len)
+        check_accs (AlexAccSkip) = AlexLastSkip  input__ IBOX(len)
+#ifndef ALEX_NOPRED
+        check_accs (AlexAccPred a predx rest)
+           | predx user__ orig_input IBOX(len) input__
+           = AlexLastAcc a input__ IBOX(len)
+           | otherwise
+           = check_accs rest
+        check_accs (AlexAccSkipPred predx rest)
+           | predx user__ orig_input IBOX(len) input__
+           = AlexLastSkip input__ IBOX(len)
+           | otherwise
+           = check_accs rest
+#endif
+
+data AlexLastAcc
+  = AlexNone
+  | AlexLastAcc !Int !AlexInput !Int
+  | AlexLastSkip     !AlexInput !Int
+
+data AlexAcc user
+  = AlexAccNone
+  | AlexAcc Int
+  | AlexAccSkip
+#ifndef ALEX_NOPRED
+  | AlexAccPred Int (AlexAccPred user) (AlexAcc user)
+  | AlexAccSkipPred (AlexAccPred user) (AlexAcc user)
+
+type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool
+
+-- -----------------------------------------------------------------------------
+-- Predicates on a rule
+
+alexAndPred p1 p2 user__ in1 len in2
+  = p1 user__ in1 len in2 && p2 user__ in1 len in2
+
+--alexPrevCharIsPred :: Char -> AlexAccPred _
+alexPrevCharIs c _ input__ _ _ = c == alexInputPrevChar input__
+
+alexPrevCharMatches f _ input__ _ _ = f (alexInputPrevChar input__)
+
+--alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _
+alexPrevCharIsOneOf arr _ input__ _ _ = arr Data.Array.! alexInputPrevChar input__
+
+--alexRightContext :: Int -> AlexAccPred _
+alexRightContext IBOX(sc) user__ _ _ input__ =
+     case alex_scan_tkn user__ input__ ILIT(0) input__ sc AlexNone of
+          (AlexNone, _) -> False
+          _ -> True
+        -- TODO: there's no need to find the longest
+        -- match when checking the right context, just
+        -- the first match will do.
+#endif
+{-# LINE 46 "Language/Clafer/Front/LexClafer.x" #-}
 tok :: (Posn -> String -> Token) -> (Posn -> String -> Token)
 tok f p s = f p s
 
@@ -125,7 +458,7 @@
                               | s == a = t
 
 resWords :: BTree
-resWords = b ">>" 34 (b "->>" 17 (b "*" 9 (b "&" 5 (b "#" 3 (b "!=" 2 (b "!" 1 N N) N) (b "%" 4 N N)) (b "(" 7 (b "&&" 6 N N) (b ")" 8 N N))) (b "," 13 (b "+" 11 (b "**" 10 N N) (b "++" 12 N N)) (b "--" 15 (b "-" 14 N N) (b "->" 16 N N)))) (b "<:" 26 (b ":=" 22 (b "/" 20 (b ".." 19 (b "." 18 N N) N) (b ":" 21 N N)) (b ";" 24 (b ":>" 23 N N) (b "<" 25 N N))) (b "=" 30 (b "<=" 28 (b "<<" 27 N N) (b "<=>" 29 N N)) (b ">" 32 (b "=>" 31 N N) (b ">=" 33 N N))))) (b "min" 51 (b "disj" 43 (b "`" 39 (b "\\" 37 (b "[" 36 (b "?" 35 N N) N) (b "]" 38 N N)) (b "all" 41 (b "abstract" 40 N N) (b "assert" 42 N N))) (b "in" 47 (b "enum" 45 (b "else" 44 N N) (b "if" 46 N N)) (b "max" 49 (b "lone" 48 N N) (b "maximize" 50 N N)))) (b "some" 60 (b "one" 56 (b "no" 54 (b "mux" 53 (b "minimize" 52 N N) N) (b "not" 55 N N)) (b "or" 58 (b "opt" 57 N N) (b "product" 59 N N))) (b "{" 64 (b "then" 62 (b "sum" 61 N N) (b "xor" 63 N N)) (b "||" 66 (b "|" 65 N N) (b "}" 67 N N)))))
+resWords = b "after" 51 (b ":>" 26 (b "," 13 (b "(" 7 (b "%" 4 (b "!=" 2 (b "!" 1 N N) (b "#" 3 N N)) (b "&&" 6 (b "&" 5 N N) N)) (b "**" 10 (b "*" 9 (b ")" 8 N N) N) (b "++" 12 (b "+" 11 N N) N))) (b "-[" 20 (b "-->>" 17 (b "--" 15 (b "-" 14 N N) (b "-->" 16 N N)) (b "->>" 19 (b "->" 18 N N) N)) (b "/" 23 (b ".." 22 (b "." 21 N N) N) (b ":=" 25 (b ":" 24 N N) N)))) (b "F" 39 (b "=" 33 (b "<<" 30 (b "<" 28 (b ";" 27 N N) (b "<:" 29 N N)) (b "<=>" 32 (b "<=" 31 N N) N)) (b ">=" 36 (b ">" 35 (b "=>" 34 N N) N) (b "?" 38 (b ">>" 37 N N) N))) (b "\\" 45 (b "W" 42 (b "U" 41 (b "G" 40 N N) N) (b "[" 44 (b "X" 43 N N) N)) (b "]->>" 48 (b "]->" 47 (b "]" 46 N N) N) (b "abstract" 50 (b "`" 49 N N) N))))) (b "maximize" 76 (b "finalref" 64 (b "disj" 58 (b "assert" 55 (b "always" 53 (b "all" 52 N N) (b "and" 54 N N)) (b "between" 57 (b "before" 56 N N) N)) (b "eventually" 61 (b "enum" 60 (b "else" 59 N N) N) (b "finally" 63 (b "final" 62 N N) N))) (b "initial" 70 (b "globally" 67 (b "follow" 66 (b "finaltarget" 65 N N) N) (b "in" 69 (b "if" 68 N N) N)) (b "lonce" 73 (b "let" 72 (b "initially" 71 N N) N) (b "max" 75 (b "lone" 74 N N) N)))) (b "product" 89 (b "no" 83 (b "mux" 80 (b "minimize" 78 (b "min" 77 N N) (b "must" 79 N N)) (b "next" 82 (b "never" 81 N N) N)) (b "opt" 86 (b "one" 85 (b "not" 84 N N) N) (b "precede" 88 (b "or" 87 N N) N))) (b "weakuntil" 95 (b "sum" 92 (b "sometime" 91 (b "some" 90 N N) N) (b "until" 94 (b "then" 93 N N) N)) (b "|" 98 (b "{" 97 (b "xor" 96 N N) N) (b "}" 100 (b "||" 99 N N) N)))))
    where b s n = let bs = id s
                   in B bs (TS bs n)
 
@@ -206,215 +539,3 @@
                         , 0x80 + ((oc `Data.Bits.shiftR` 6) Data.Bits..&. 0x3f)
                         , 0x80 + oc Data.Bits..&. 0x3f
                         ]
-
-alex_action_1 =  tok (\p s -> PT p (eitherResIdent (TV . share) s))
-alex_action_2 =  tok (\p s -> PT p (eitherResIdent (T_PosInteger . share) s))
-alex_action_3 =  tok (\p s -> PT p (eitherResIdent (T_PosDouble . share) s))
-alex_action_4 =  tok (\p s -> PT p (eitherResIdent (T_PosReal . share) s))
-alex_action_5 =  tok (\p s -> PT p (eitherResIdent (T_PosString . share) s))
-alex_action_6 =  tok (\p s -> PT p (eitherResIdent (T_PosIdent . share) s))
-alex_action_7 =  tok (\p s -> PT p (eitherResIdent (T_PosLineComment . share) s))
-alex_action_8 =  tok (\p s -> PT p (eitherResIdent (T_PosBlockComment . share) s))
-alex_action_9 =  tok (\p s -> PT p (eitherResIdent (T_PosAlloy . share) s))
-alex_action_10 =  tok (\p s -> PT p (eitherResIdent (T_PosChoco . share) s))
-alex_action_11 =  tok (\p s -> PT p (eitherResIdent (TV . share) s))
-{-# LINE 1 "templates\GenericTemplate.hs" #-}
-{-# LINE 1 "templates\\GenericTemplate.hs" #-}
-{-# LINE 1 "<built-in>" #-}
-{-# LINE 1 "<command-line>" #-}
-{-# LINE 11 "<command-line>" #-}
-{-# LINE 1 "C:\\Users\\mantkiew\\AppData\\Local\\Programs\\stack\\x86_64-windows\\ghc-7.10.3\\lib/include\\ghcversion.h" #-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-{-# LINE 11 "<command-line>" #-}
-{-# LINE 1 "templates\\GenericTemplate.hs" #-}
--- -----------------------------------------------------------------------------
--- ALEX TEMPLATE
---
--- This code is in the PUBLIC DOMAIN; you may copy it freely and use
--- it for any purpose whatsoever.
-
--- -----------------------------------------------------------------------------
--- INTERNALS and main scanner engine
-
-{-# LINE 21 "templates\\GenericTemplate.hs" #-}
-
-
-
-
-
--- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
-#if __GLASGOW_HASKELL__ > 706
-#define GTE(n,m) (tagToEnum# (n >=# m))
-#define EQ(n,m) (tagToEnum# (n ==# m))
-#else
-#define GTE(n,m) (n >=# m)
-#define EQ(n,m) (n ==# m)
-#endif
-{-# LINE 51 "templates\\GenericTemplate.hs" #-}
-
-
-data AlexAddr = AlexA# Addr#
--- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
-#if __GLASGOW_HASKELL__ < 503
-uncheckedShiftL# = shiftL#
-#endif
-
-{-# INLINE alexIndexInt16OffAddr #-}
-alexIndexInt16OffAddr (AlexA# arr) off =
-#ifdef WORDS_BIGENDIAN
-  narrow16Int# i
-  where
-        i    = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)
-        high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))
-        low  = int2Word# (ord# (indexCharOffAddr# arr off'))
-        off' = off *# 2#
-#else
-  indexInt16OffAddr# arr off
-#endif
-
-
-
-
-
-{-# INLINE alexIndexInt32OffAddr #-}
-alexIndexInt32OffAddr (AlexA# arr) off =
-#ifdef WORDS_BIGENDIAN
-  narrow32Int# i
-  where
-   i    = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#`
-                     (b2 `uncheckedShiftL#` 16#) `or#`
-                     (b1 `uncheckedShiftL#` 8#) `or#` b0)
-   b3   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#)))
-   b2   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#)))
-   b1   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))
-   b0   = int2Word# (ord# (indexCharOffAddr# arr off'))
-   off' = off *# 4#
-#else
-  indexInt32OffAddr# arr off
-#endif
-
-
-
-
-
-
-#if __GLASGOW_HASKELL__ < 503
-quickIndex arr i = arr ! i
-#else
--- GHC >= 503, unsafeAt is available from Data.Array.Base.
-quickIndex = unsafeAt
-#endif
-
-
-
-
--- -----------------------------------------------------------------------------
--- Main lexing routines
-
-data AlexReturn a
-  = AlexEOF
-  | AlexError  !AlexInput
-  | AlexSkip   !AlexInput !Int
-  | AlexToken  !AlexInput !Int a
-
--- alexScan :: AlexInput -> StartCode -> AlexReturn a
-alexScan input (I# (sc))
-  = alexScanUser undefined input (I# (sc))
-
-alexScanUser user input (I# (sc))
-  = case alex_scan_tkn user input 0# input sc AlexNone of
-        (AlexNone, input') ->
-                case alexGetByte input of
-                        Nothing ->
-
-
-
-                                   AlexEOF
-                        Just _ ->
-
-
-
-                                   AlexError input'
-
-        (AlexLastSkip input'' len, _) ->
-
-
-
-                AlexSkip input'' len
-
-        (AlexLastAcc k input''' len, _) ->
-
-
-
-                AlexToken input''' len k
-
-
--- Push the input through the DFA, remembering the most recent accepting
--- state it encountered.
-
-alex_scan_tkn user orig_input len input s last_acc =
-  input `seq` -- strict in the input
-  let
-        new_acc = (check_accs (alex_accept `quickIndex` (I# (s))))
-  in
-  new_acc `seq`
-  case alexGetByte input of
-     Nothing -> (new_acc, input)
-     Just (c, new_input) ->
-
-
-
-      case fromIntegral c of { (I# (ord_c)) ->
-        let
-                base   = alexIndexInt32OffAddr alex_base s
-                offset = (base +# ord_c)
-                check  = alexIndexInt16OffAddr alex_check offset
-
-                new_s = if GTE(offset,0#) && EQ(check,ord_c)
-                          then alexIndexInt16OffAddr alex_table offset
-                          else alexIndexInt16OffAddr alex_deflt s
-        in
-        case new_s of
-            -1# -> (new_acc, input)
-                -- on an error, we want to keep the input *before* the
-                -- character that failed, not after.
-            _ -> alex_scan_tkn user orig_input (if c < 0x80 || c >= 0xC0 then (len +# 1#) else len)
-                                                -- note that the length is increased ONLY if this is the 1st byte in a char encoding)
-                        new_input new_s new_acc
-      }
-  where
-        check_accs (AlexAccNone) = last_acc
-        check_accs (AlexAcc a  ) = AlexLastAcc a input (I# (len))
-        check_accs (AlexAccSkip) = AlexLastSkip  input (I# (len))
-{-# LINE 198 "templates\\GenericTemplate.hs" #-}
-
-data AlexLastAcc a
-  = AlexNone
-  | AlexLastAcc a !AlexInput !Int
-  | AlexLastSkip  !AlexInput !Int
-
-instance Functor AlexLastAcc where
-    fmap _ AlexNone = AlexNone
-    fmap f (AlexLastAcc x y z) = AlexLastAcc (f x) y z
-    fmap _ (AlexLastSkip x y) = AlexLastSkip x y
-
-data AlexAcc a user
-  = AlexAccNone
-  | AlexAcc a
-  | AlexAccSkip
diff --git a/src/Language/Clafer/Front/LexClafer.x b/src/Language/Clafer/Front/LexClafer.x
new file mode 100644
--- /dev/null
+++ b/src/Language/Clafer/Front/LexClafer.x
@@ -0,0 +1,207 @@
+-- -*- haskell -*-
+-- This Alex file was machine-generated by the BNF converter
+{
+{-# OPTIONS -fno-warn-incomplete-patterns #-}
+{-# OPTIONS_GHC -w #-}
+module Language.Clafer.Front.LexClafer where
+
+
+
+import qualified Data.Bits
+import Data.Word (Word8)
+import Data.Char (ord)
+}
+
+
+$l = [a-zA-Z\192 - \255] # [\215 \247]    -- isolatin1 letter FIXME
+$c = [A-Z\192-\221] # [\215]    -- capital isolatin1 letter FIXME
+$s = [a-z\222-\255] # [\247]    -- small isolatin1 letter FIXME
+$d = [0-9]                -- digit
+$i = [$l $d _ ']          -- identifier character
+$u = [\0-\255]          -- universal: any character
+
+@rsyms =    -- symbols and non-identifier-like reserved words
+   \= | \[ | \] | \< \< | \> \> | \{ | \} | \` | \: | \- \> | \- \> \> | \: \= | \? | \+ | \* | \. \. | \| | \< \= \> | \= \> | \| \| | \& \& | \! | \< | \> | \< \= | \> \= | \! \= | \- | \/ | \% | \# | \< \: | \: \> | \+ \+ | \, | \- \- | \* \* | \& | \. | \- \- \> \> | \- \[ | \] \- \> \> | \- \- \> | \] \- \> | \; | \\ | \( | \)
+
+:-
+
+$white+ ;
+@rsyms { tok (\p s -> PT p (eitherResIdent (TV . share) s)) }
+$d + { tok (\p s -> PT p (eitherResIdent (T_PosInteger . share) s)) }
+$d + \. $d + e \- ? $d + { tok (\p s -> PT p (eitherResIdent (T_PosDouble . share) s)) }
+$d + \. $d + { tok (\p s -> PT p (eitherResIdent (T_PosReal . share) s)) }
+\" ($u # [\" \\]| \\ [\" \\ n t]) * \" { tok (\p s -> PT p (eitherResIdent (T_PosString . share) s)) }
+$l ($l | $d | \_ | \')* { tok (\p s -> PT p (eitherResIdent (T_PosIdent . share) s)) }
+\/ \/ ($u # \n)* { tok (\p s -> PT p (eitherResIdent (T_PosLineComment . share) s)) }
+\/ \* ($u # \* | \* + ($u # [\* \/]))* \* + \/ { tok (\p s -> PT p (eitherResIdent (T_PosBlockComment . share) s)) }
+\[ a l l o y \| ($u # \| | \| + ($u # \])) * (\| \]) { tok (\p s -> PT p (eitherResIdent (T_PosAlloy . share) s)) }
+\[ c h o c o \| ($u # \| | \| + ($u # \])) * (\| \]) { tok (\p s -> PT p (eitherResIdent (T_PosChoco . share) s)) }
+
+$l $i*   { tok (\p s -> PT p (eitherResIdent (TV . share) s)) }
+
+
+
+
+
+{
+
+tok :: (Posn -> String -> Token) -> (Posn -> String -> Token)
+tok f p s = f p s
+
+share :: String -> String
+share = id
+
+data Tok =
+   TS !String !Int    -- reserved words and symbols
+ | TL !String         -- string literals
+ | TI !String         -- integer literals
+ | TV !String         -- identifiers
+ | TD !String         -- double precision float literals
+ | TC !String         -- character literals
+ | T_PosInteger !String
+ | T_PosDouble !String
+ | T_PosReal !String
+ | T_PosString !String
+ | T_PosIdent !String
+ | T_PosLineComment !String
+ | T_PosBlockComment !String
+ | T_PosAlloy !String
+ | T_PosChoco !String
+
+ deriving (Eq,Show,Ord)
+
+data Token =
+   PT  Posn Tok
+ | Err Posn
+  deriving (Eq,Show,Ord)
+
+tokenPos :: [Token] -> String
+tokenPos (PT (Pn _ l _) _ :_) = "line " ++ show l
+tokenPos (Err (Pn _ l _) :_) = "line " ++ show l
+tokenPos _ = "end of file"
+
+tokenPosn :: Token -> Posn
+tokenPosn (PT p _) = p
+tokenPosn (Err p) = p
+
+tokenLineCol :: Token -> (Int, Int)
+tokenLineCol = posLineCol . tokenPosn
+
+posLineCol :: Posn -> (Int, Int)
+posLineCol (Pn _ l c) = (l,c)
+
+mkPosToken :: Token -> ((Int, Int), String)
+mkPosToken t@(PT p _) = (posLineCol p, prToken t)
+
+prToken :: Token -> String
+prToken t = case t of
+  PT _ (TS s _) -> s
+  PT _ (TL s)   -> show s
+  PT _ (TI s)   -> s
+  PT _ (TV s)   -> s
+  PT _ (TD s)   -> s
+  PT _ (TC s)   -> s
+  PT _ (T_PosInteger s) -> s
+  PT _ (T_PosDouble s) -> s
+  PT _ (T_PosReal s) -> s
+  PT _ (T_PosString s) -> s
+  PT _ (T_PosIdent s) -> s
+  PT _ (T_PosLineComment s) -> s
+  PT _ (T_PosBlockComment s) -> s
+  PT _ (T_PosAlloy s) -> s
+  PT _ (T_PosChoco s) -> s
+
+
+data BTree = N | B String Tok BTree BTree deriving (Show)
+
+eitherResIdent :: (String -> Tok) -> String -> Tok
+eitherResIdent tv s = treeFind resWords
+  where
+  treeFind N = tv s
+  treeFind (B a t left right) | s < a  = treeFind left
+                              | s > a  = treeFind right
+                              | s == a = t
+
+resWords :: BTree
+resWords = b "after" 51 (b ":>" 26 (b "," 13 (b "(" 7 (b "%" 4 (b "!=" 2 (b "!" 1 N N) (b "#" 3 N N)) (b "&&" 6 (b "&" 5 N N) N)) (b "**" 10 (b "*" 9 (b ")" 8 N N) N) (b "++" 12 (b "+" 11 N N) N))) (b "-[" 20 (b "-->>" 17 (b "--" 15 (b "-" 14 N N) (b "-->" 16 N N)) (b "->>" 19 (b "->" 18 N N) N)) (b "/" 23 (b ".." 22 (b "." 21 N N) N) (b ":=" 25 (b ":" 24 N N) N)))) (b "F" 39 (b "=" 33 (b "<<" 30 (b "<" 28 (b ";" 27 N N) (b "<:" 29 N N)) (b "<=>" 32 (b "<=" 31 N N) N)) (b ">=" 36 (b ">" 35 (b "=>" 34 N N) N) (b "?" 38 (b ">>" 37 N N) N))) (b "\\" 45 (b "W" 42 (b "U" 41 (b "G" 40 N N) N) (b "[" 44 (b "X" 43 N N) N)) (b "]->>" 48 (b "]->" 47 (b "]" 46 N N) N) (b "abstract" 50 (b "`" 49 N N) N))))) (b "maximize" 76 (b "finalref" 64 (b "disj" 58 (b "assert" 55 (b "always" 53 (b "all" 52 N N) (b "and" 54 N N)) (b "between" 57 (b "before" 56 N N) N)) (b "eventually" 61 (b "enum" 60 (b "else" 59 N N) N) (b "finally" 63 (b "final" 62 N N) N))) (b "initial" 70 (b "globally" 67 (b "follow" 66 (b "finaltarget" 65 N N) N) (b "in" 69 (b "if" 68 N N) N)) (b "lonce" 73 (b "let" 72 (b "initially" 71 N N) N) (b "max" 75 (b "lone" 74 N N) N)))) (b "product" 89 (b "no" 83 (b "mux" 80 (b "minimize" 78 (b "min" 77 N N) (b "must" 79 N N)) (b "next" 82 (b "never" 81 N N) N)) (b "opt" 86 (b "one" 85 (b "not" 84 N N) N) (b "precede" 88 (b "or" 87 N N) N))) (b "weakuntil" 95 (b "sum" 92 (b "sometime" 91 (b "some" 90 N N) N) (b "until" 94 (b "then" 93 N N) N)) (b "|" 98 (b "{" 97 (b "xor" 96 N N) N) (b "}" 100 (b "||" 99 N N) N)))))
+   where b s n = let bs = id s
+                  in B bs (TS bs n)
+
+unescapeInitTail :: String -> String
+unescapeInitTail = id . unesc . tail . id where
+  unesc s = case s of
+    '\\':c:cs | elem c ['\"', '\\', '\''] -> c : unesc cs
+    '\\':'n':cs  -> '\n' : unesc cs
+    '\\':'t':cs  -> '\t' : unesc cs
+    '"':[]    -> []
+    c:cs      -> c : unesc cs
+    _         -> []
+
+-------------------------------------------------------------------
+-- Alex wrapper code.
+-- A modified "posn" wrapper.
+-------------------------------------------------------------------
+
+data Posn = Pn !Int !Int !Int
+      deriving (Eq, Show,Ord)
+
+alexStartPos :: Posn
+alexStartPos = Pn 0 1 1
+
+alexMove :: Posn -> Char -> Posn
+alexMove (Pn a l c) '\t' = Pn (a+1)  l     (((c+7) `div` 8)*8+1)
+alexMove (Pn a l c) '\n' = Pn (a+1) (l+1)   1
+alexMove (Pn a l c) _    = Pn (a+1)  l     (c+1)
+
+type Byte = Word8
+
+type AlexInput = (Posn,     -- current position,
+                  Char,     -- previous char
+                  [Byte],   -- pending bytes on the current char
+                  String)   -- current input string
+
+tokens :: String -> [Token]
+tokens str = go (alexStartPos, '\n', [], str)
+    where
+      go :: AlexInput -> [Token]
+      go inp@(pos, _, _, str) =
+               case alexScan inp 0 of
+                AlexEOF                   -> []
+                AlexError (pos, _, _, _)  -> [Err pos]
+                AlexSkip  inp' len        -> go inp'
+                AlexToken inp' len act    -> act pos (take len str) : (go inp')
+
+alexGetByte :: AlexInput -> Maybe (Byte,AlexInput)
+alexGetByte (p, c, (b:bs), s) = Just (b, (p, c, bs, s))
+alexGetByte (p, _, [], s) =
+  case  s of
+    []  -> Nothing
+    (c:s) ->
+             let p'     = alexMove p c
+                 (b:bs) = utf8Encode c
+              in p' `seq` Just (b, (p', c, bs, s))
+
+alexInputPrevChar :: AlexInput -> Char
+alexInputPrevChar (p, c, bs, s) = c
+
+-- | Encode a Haskell String to a list of Word8 values, in UTF8 format.
+utf8Encode :: Char -> [Word8]
+utf8Encode = map fromIntegral . go . ord
+ where
+  go oc
+   | oc <= 0x7f       = [oc]
+
+   | oc <= 0x7ff      = [ 0xc0 + (oc `Data.Bits.shiftR` 6)
+                        , 0x80 + oc Data.Bits..&. 0x3f
+                        ]
+
+   | oc <= 0xffff     = [ 0xe0 + (oc `Data.Bits.shiftR` 12)
+                        , 0x80 + ((oc `Data.Bits.shiftR` 6) Data.Bits..&. 0x3f)
+                        , 0x80 + oc Data.Bits..&. 0x3f
+                        ]
+   | otherwise        = [ 0xf0 + (oc `Data.Bits.shiftR` 18)
+                        , 0x80 + ((oc `Data.Bits.shiftR` 12) Data.Bits..&. 0x3f)
+                        , 0x80 + ((oc `Data.Bits.shiftR` 6) Data.Bits..&. 0x3f)
+                        , 0x80 + oc Data.Bits..&. 0x3f
+                        ]
+}
diff --git a/src/Language/Clafer/Front/ParClafer.hs b/src/Language/Clafer/Front/ParClafer.hs
--- a/src/Language/Clafer/Front/ParClafer.hs
+++ b/src/Language/Clafer/Front/ParClafer.hs
@@ -1,2172 +1,3146 @@
 {-# OPTIONS_GHC -w #-}
-{-# OPTIONS -fglasgow-exts -cpp #-}
-{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
-module Language.Clafer.Front.ParClafer where
-import Language.Clafer.Front.AbsClafer
-import Language.Clafer.Front.LexClafer
-import Language.Clafer.Front.ErrM
-import qualified Data.Array as Happy_Data_Array
-import qualified GHC.Exts as Happy_GHC_Exts
-import Control.Applicative(Applicative(..))
-import Control.Monad (ap)
-
--- parser produced by Happy Version 1.19.5
-
-newtype HappyAbsSyn  = HappyAbsSyn HappyAny
-#if __GLASGOW_HASKELL__ >= 607
-type HappyAny = Happy_GHC_Exts.Any
-#else
-type HappyAny = forall a . a
-#endif
-happyIn8 :: (PosInteger) -> (HappyAbsSyn )
-happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn8 #-}
-happyOut8 :: (HappyAbsSyn ) -> (PosInteger)
-happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut8 #-}
-happyIn9 :: (PosDouble) -> (HappyAbsSyn )
-happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn9 #-}
-happyOut9 :: (HappyAbsSyn ) -> (PosDouble)
-happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut9 #-}
-happyIn10 :: (PosReal) -> (HappyAbsSyn )
-happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn10 #-}
-happyOut10 :: (HappyAbsSyn ) -> (PosReal)
-happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut10 #-}
-happyIn11 :: (PosString) -> (HappyAbsSyn )
-happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn11 #-}
-happyOut11 :: (HappyAbsSyn ) -> (PosString)
-happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut11 #-}
-happyIn12 :: (PosIdent) -> (HappyAbsSyn )
-happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn12 #-}
-happyOut12 :: (HappyAbsSyn ) -> (PosIdent)
-happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut12 #-}
-happyIn13 :: (PosLineComment) -> (HappyAbsSyn )
-happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn13 #-}
-happyOut13 :: (HappyAbsSyn ) -> (PosLineComment)
-happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut13 #-}
-happyIn14 :: (PosBlockComment) -> (HappyAbsSyn )
-happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn14 #-}
-happyOut14 :: (HappyAbsSyn ) -> (PosBlockComment)
-happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut14 #-}
-happyIn15 :: (PosAlloy) -> (HappyAbsSyn )
-happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn15 #-}
-happyOut15 :: (HappyAbsSyn ) -> (PosAlloy)
-happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut15 #-}
-happyIn16 :: (PosChoco) -> (HappyAbsSyn )
-happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn16 #-}
-happyOut16 :: (HappyAbsSyn ) -> (PosChoco)
-happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut16 #-}
-happyIn17 :: (Module) -> (HappyAbsSyn )
-happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn17 #-}
-happyOut17 :: (HappyAbsSyn ) -> (Module)
-happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut17 #-}
-happyIn18 :: (Declaration) -> (HappyAbsSyn )
-happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn18 #-}
-happyOut18 :: (HappyAbsSyn ) -> (Declaration)
-happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut18 #-}
-happyIn19 :: (Clafer) -> (HappyAbsSyn )
-happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn19 #-}
-happyOut19 :: (HappyAbsSyn ) -> (Clafer)
-happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut19 #-}
-happyIn20 :: (Constraint) -> (HappyAbsSyn )
-happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn20 #-}
-happyOut20 :: (HappyAbsSyn ) -> (Constraint)
-happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut20 #-}
-happyIn21 :: (Assertion) -> (HappyAbsSyn )
-happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn21 #-}
-happyOut21 :: (HappyAbsSyn ) -> (Assertion)
-happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut21 #-}
-happyIn22 :: (Goal) -> (HappyAbsSyn )
-happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn22 #-}
-happyOut22 :: (HappyAbsSyn ) -> (Goal)
-happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut22 #-}
-happyIn23 :: (Abstract) -> (HappyAbsSyn )
-happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn23 #-}
-happyOut23 :: (HappyAbsSyn ) -> (Abstract)
-happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut23 #-}
-happyIn24 :: (Elements) -> (HappyAbsSyn )
-happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn24 #-}
-happyOut24 :: (HappyAbsSyn ) -> (Elements)
-happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut24 #-}
-happyIn25 :: (Element) -> (HappyAbsSyn )
-happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn25 #-}
-happyOut25 :: (HappyAbsSyn ) -> (Element)
-happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut25 #-}
-happyIn26 :: (Super) -> (HappyAbsSyn )
-happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn26 #-}
-happyOut26 :: (HappyAbsSyn ) -> (Super)
-happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut26 #-}
-happyIn27 :: (Reference) -> (HappyAbsSyn )
-happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn27 #-}
-happyOut27 :: (HappyAbsSyn ) -> (Reference)
-happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut27 #-}
-happyIn28 :: (Init) -> (HappyAbsSyn )
-happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn28 #-}
-happyOut28 :: (HappyAbsSyn ) -> (Init)
-happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut28 #-}
-happyIn29 :: (InitHow) -> (HappyAbsSyn )
-happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn29 #-}
-happyOut29 :: (HappyAbsSyn ) -> (InitHow)
-happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut29 #-}
-happyIn30 :: (GCard) -> (HappyAbsSyn )
-happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn30 #-}
-happyOut30 :: (HappyAbsSyn ) -> (GCard)
-happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut30 #-}
-happyIn31 :: (Card) -> (HappyAbsSyn )
-happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn31 #-}
-happyOut31 :: (HappyAbsSyn ) -> (Card)
-happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut31 #-}
-happyIn32 :: (NCard) -> (HappyAbsSyn )
-happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn32 #-}
-happyOut32 :: (HappyAbsSyn ) -> (NCard)
-happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut32 #-}
-happyIn33 :: (ExInteger) -> (HappyAbsSyn )
-happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn33 #-}
-happyOut33 :: (HappyAbsSyn ) -> (ExInteger)
-happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut33 #-}
-happyIn34 :: (Name) -> (HappyAbsSyn )
-happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn34 #-}
-happyOut34 :: (HappyAbsSyn ) -> (Name)
-happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut34 #-}
-happyIn35 :: (Exp) -> (HappyAbsSyn )
-happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn35 #-}
-happyOut35 :: (HappyAbsSyn ) -> (Exp)
-happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut35 #-}
-happyIn36 :: (Exp) -> (HappyAbsSyn )
-happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn36 #-}
-happyOut36 :: (HappyAbsSyn ) -> (Exp)
-happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut36 #-}
-happyIn37 :: (Exp) -> (HappyAbsSyn )
-happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn37 #-}
-happyOut37 :: (HappyAbsSyn ) -> (Exp)
-happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut37 #-}
-happyIn38 :: (Exp) -> (HappyAbsSyn )
-happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn38 #-}
-happyOut38 :: (HappyAbsSyn ) -> (Exp)
-happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut38 #-}
-happyIn39 :: (Exp) -> (HappyAbsSyn )
-happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn39 #-}
-happyOut39 :: (HappyAbsSyn ) -> (Exp)
-happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut39 #-}
-happyIn40 :: (Exp) -> (HappyAbsSyn )
-happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn40 #-}
-happyOut40 :: (HappyAbsSyn ) -> (Exp)
-happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut40 #-}
-happyIn41 :: (Exp) -> (HappyAbsSyn )
-happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn41 #-}
-happyOut41 :: (HappyAbsSyn ) -> (Exp)
-happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut41 #-}
-happyIn42 :: (Exp) -> (HappyAbsSyn )
-happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn42 #-}
-happyOut42 :: (HappyAbsSyn ) -> (Exp)
-happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut42 #-}
-happyIn43 :: (Exp) -> (HappyAbsSyn )
-happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn43 #-}
-happyOut43 :: (HappyAbsSyn ) -> (Exp)
-happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut43 #-}
-happyIn44 :: (Exp) -> (HappyAbsSyn )
-happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn44 #-}
-happyOut44 :: (HappyAbsSyn ) -> (Exp)
-happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut44 #-}
-happyIn45 :: (Exp) -> (HappyAbsSyn )
-happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn45 #-}
-happyOut45 :: (HappyAbsSyn ) -> (Exp)
-happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut45 #-}
-happyIn46 :: (Exp) -> (HappyAbsSyn )
-happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn46 #-}
-happyOut46 :: (HappyAbsSyn ) -> (Exp)
-happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut46 #-}
-happyIn47 :: (Exp) -> (HappyAbsSyn )
-happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn47 #-}
-happyOut47 :: (HappyAbsSyn ) -> (Exp)
-happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut47 #-}
-happyIn48 :: (Exp) -> (HappyAbsSyn )
-happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn48 #-}
-happyOut48 :: (HappyAbsSyn ) -> (Exp)
-happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut48 #-}
-happyIn49 :: (Exp) -> (HappyAbsSyn )
-happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn49 #-}
-happyOut49 :: (HappyAbsSyn ) -> (Exp)
-happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut49 #-}
-happyIn50 :: (Exp) -> (HappyAbsSyn )
-happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn50 #-}
-happyOut50 :: (HappyAbsSyn ) -> (Exp)
-happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut50 #-}
-happyIn51 :: (Exp) -> (HappyAbsSyn )
-happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn51 #-}
-happyOut51 :: (HappyAbsSyn ) -> (Exp)
-happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut51 #-}
-happyIn52 :: (Exp) -> (HappyAbsSyn )
-happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn52 #-}
-happyOut52 :: (HappyAbsSyn ) -> (Exp)
-happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut52 #-}
-happyIn53 :: (Exp) -> (HappyAbsSyn )
-happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn53 #-}
-happyOut53 :: (HappyAbsSyn ) -> (Exp)
-happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut53 #-}
-happyIn54 :: (Decl) -> (HappyAbsSyn )
-happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn54 #-}
-happyOut54 :: (HappyAbsSyn ) -> (Decl)
-happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut54 #-}
-happyIn55 :: (Quant) -> (HappyAbsSyn )
-happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn55 #-}
-happyOut55 :: (HappyAbsSyn ) -> (Quant)
-happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut55 #-}
-happyIn56 :: (EnumId) -> (HappyAbsSyn )
-happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn56 #-}
-happyOut56 :: (HappyAbsSyn ) -> (EnumId)
-happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut56 #-}
-happyIn57 :: (ModId) -> (HappyAbsSyn )
-happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn57 #-}
-happyOut57 :: (HappyAbsSyn ) -> (ModId)
-happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut57 #-}
-happyIn58 :: (LocId) -> (HappyAbsSyn )
-happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn58 #-}
-happyOut58 :: (HappyAbsSyn ) -> (LocId)
-happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut58 #-}
-happyIn59 :: ([Declaration]) -> (HappyAbsSyn )
-happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn59 #-}
-happyOut59 :: (HappyAbsSyn ) -> ([Declaration])
-happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut59 #-}
-happyIn60 :: ([EnumId]) -> (HappyAbsSyn )
-happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn60 #-}
-happyOut60 :: (HappyAbsSyn ) -> ([EnumId])
-happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut60 #-}
-happyIn61 :: ([Element]) -> (HappyAbsSyn )
-happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn61 #-}
-happyOut61 :: (HappyAbsSyn ) -> ([Element])
-happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut61 #-}
-happyIn62 :: ([Exp]) -> (HappyAbsSyn )
-happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn62 #-}
-happyOut62 :: (HappyAbsSyn ) -> ([Exp])
-happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut62 #-}
-happyIn63 :: ([LocId]) -> (HappyAbsSyn )
-happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn63 #-}
-happyOut63 :: (HappyAbsSyn ) -> ([LocId])
-happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut63 #-}
-happyIn64 :: ([ModId]) -> (HappyAbsSyn )
-happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn64 #-}
-happyOut64 :: (HappyAbsSyn ) -> ([ModId])
-happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut64 #-}
-happyIn65 :: (Exp) -> (HappyAbsSyn )
-happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn65 #-}
-happyOut65 :: (HappyAbsSyn ) -> (Exp)
-happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut65 #-}
-happyInTok :: (Token) -> (HappyAbsSyn )
-happyInTok x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyInTok #-}
-happyOutTok :: (HappyAbsSyn ) -> (Token)
-happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOutTok #-}
-
-
-happyActOffsets :: HappyAddr
-happyActOffsets = HappyA# "\x00\x00\x10\x01\x15\x01\x09\x01\x13\x01\xf0\x00\x00\x00\xe2\x00\x95\x00\xe2\x00\x02\x01\xda\x00\x00\x00\xda\x00\xa0\x00\x00\x00\xda\x00\xac\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\xe1\x00\x0f\x01\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x00\xb2\x00\x6a\x00\x22\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x05\x01\xd9\x00\xdf\x00\x14\x01\x00\x00\xc2\x05\x00\x00\x61\x00\x09\x00\x00\x00\x00\x00\xff\x00\x01\x01\xc4\x00\x03\x01\x0b\x00\xfe\x00\x00\x00\x66\x01\xea\x00\x00\x00\x00\x00\xcf\x00\x1d\x00\x42\x01\x1d\x00\x00\x00\xde\xff\x42\x01\x00\x00\x3c\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x00\xfd\xff\xef\x00\xfc\xff\xfb\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x00\x00\xab\x00\x1d\x00\xe4\x00\xe4\x00\x00\x00\x00\x00\x11\x00\x00\x00\xc2\x00\xdc\x00\xde\x00\xb4\x00\xd6\x00\x04\x00\xd6\x00\xc2\x05\x3c\x00\xad\x00\xfe\xff\x00\x00\xb1\x00\xa9\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x1d\x00\x50\x01\x50\x01\x50\x01\x50\x01\x50\x01\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xbd\x00\x87\x00\x87\x00\x87\x00\x87\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\xac\x00\xe0\x00\x00\x00\xcf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x09\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x9e\x00\xd2\x00\xd2\x00\x0b\x00\xaf\x00\xaf\x00\x00\x00\x96\x00\x42\x01\x00\x00\x00\x00\x75\x00\x1d\x00\x8b\x00\x42\x01\x42\x01\x92\x00\xfc\xff\x1d\x00\x1d\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\xf0\xff\x6c\x00\x9e\x00\x9e\x00\x38\x00\xed\xff\x81\x00\x00\x00\x9e\x00\x42\x01\x81\x00\x42\x01\x00\x00\x81\x00\x81\x00\x42\x01\x56\x00\x42\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x7f\x00\x00\x00"#
-
-happyGotoOffsets :: HappyAddr
-happyGotoOffsets = HappyA# "\xf8\xff\x13\x00\x85\x00\x80\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x7c\x00\x00\x00\x00\x00\xd0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x7a\x00\x00\x00\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x03\x53\x00\x51\x00\x45\x00\x3a\x00\x1b\x00\x5b\x03\x5b\x03\x5b\x03\x5b\x03\x5b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x05\x00\x00\x00\x00\x00\x00\x70\x04\x1c\x07\x29\x03\xfd\x06\x00\x00\x71\x00\xf7\x02\x00\x00\xb6\x06\x97\x06\x00\x00\x00\x00\x00\x00\xe9\x06\x00\x00\xca\x06\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x03\x00\x00\x00\x6e\x00\x00\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x08\x00\x02\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x06\x0a\x00\x00\x00\x00\x00\x00\x00\x29\x00\x08\x08\xfc\x07\xc9\x07\xc3\x07\xbb\x07\xa7\x07\x88\x07\x30\x07\x64\x06\x50\x06\x31\x06\x1d\x06\xeb\x05\xa4\x05\x89\x05\x57\x05\x3c\x05\x0a\x05\xef\x04\xbd\x04\x00\x00\x55\x04\x23\x04\xf1\x03\xbf\x03\x8d\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\x02\x00\x00\x00\x00\x00\x00\x74\x07\x93\x00\x93\x02\x61\x02\x00\x00\x5c\x00\x6b\x07\x39\x07\x00\x00\x00\x00\x00\x00\x00\x00\xdc\xff\xfa\x01\x79\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x02\x00\x00\xfd\x01\x00\x00\x00\x00\x00\x00\xcb\x01\x18\x00\x99\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
-
-happyDefActions :: HappyAddr
-happyDefActions = HappyA# "\x7d\xff\xe7\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfa\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\xff\x00\x00\xd5\xff\xe6\xff\x00\x00\xe7\xff\x7c\xff\xe3\xff\xe1\xff\xdf\xff\xe0\xff\xef\xff\x00\x00\x00\x00\x00\x00\x00\x00\xd0\xff\xd2\xff\xd1\xff\xd3\xff\xd4\xff\x00\x00\x77\xff\x77\xff\x77\xff\x77\xff\x77\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\xff\x8a\xff\x89\xff\x88\xff\x7f\xff\x8c\xff\x76\xff\x71\xff\xbd\xff\xbb\xff\xb9\xff\xb7\xff\xb5\xff\xac\xff\xaa\xff\xa7\xff\xa3\xff\xa0\xff\x9b\xff\x99\xff\x97\xff\x94\xff\x92\xff\x8f\xff\x8d\xff\x00\x00\x73\xff\xc6\xff\xbf\xff\x00\x00\x00\x00\x00\x00\x00\x00\xed\xff\x00\x00\x00\x00\x83\xff\x00\x00\x00\x00\x85\xff\x84\xff\x82\xff\x00\x00\x81\xff\x00\x00\xf9\xff\xf8\xff\xf7\xff\xf6\xff\xde\xff\x00\x00\x00\x00\xcf\xff\xcb\xff\xe5\xff\xca\xff\xcc\xff\xcd\xff\xce\xff\x00\x00\xc7\xff\xc9\xff\xc8\xff\xdc\xff\x00\x00\x9f\xff\x9e\xff\xa1\xff\xa2\xff\x00\x00\x7e\xff\x00\x00\x75\xff\x00\x00\x00\x00\x9c\xff\x00\x00\x9d\xff\xb6\xff\x00\x00\x00\x00\x7f\xff\xab\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\xff\xea\xff\xe8\xff\xeb\xff\xe9\xff\xc0\xff\xbe\xff\xbc\xff\xba\xff\xb8\xff\x00\x00\xae\xff\xb0\xff\xb3\xff\xb2\xff\xb1\xff\xb4\xff\xaf\xff\xa8\xff\xa9\xff\xa5\xff\xa6\xff\xa4\xff\x9a\xff\x98\xff\x95\xff\x96\xff\x93\xff\x91\xff\x90\xff\x8e\xff\x00\x00\x00\x00\x72\xff\x87\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\xff\xcf\xff\x00\x00\x00\x00\x80\xff\x7b\xff\xf0\xff\xe2\xff\x79\xff\xe7\xff\x00\x00\xda\xff\xdb\xff\xd9\xff\x00\x00\xc4\xff\x74\xff\x86\xff\x00\x00\xc2\xff\x00\x00\xad\xff\xc3\xff\xc5\xff\x00\x00\xe5\xff\x00\x00\xd6\xff\xd7\xff\x7a\xff\x78\xff\xe4\xff\xd8\xff\xee\xff\xc1\xff"#
-
-happyCheck :: HappyAddr
-happyCheck = HappyA# "\xff\xff\x09\x00\x01\x00\x00\x00\x03\x00\x09\x00\x09\x00\x0b\x00\x07\x00\x2b\x00\x1d\x00\x1b\x00\x08\x00\x04\x00\x04\x00\x0e\x00\x05\x00\x35\x00\x09\x00\x15\x00\x24\x00\x0a\x00\x18\x00\x27\x00\x28\x00\x2c\x00\x2a\x00\x13\x00\x19\x00\x14\x00\x0b\x00\x23\x00\x04\x00\x1d\x00\x0f\x00\x01\x00\x07\x00\x03\x00\x48\x00\x26\x00\x10\x00\x07\x00\x29\x00\x33\x00\x12\x00\x04\x00\x1d\x00\x2e\x00\x0e\x00\x30\x00\x31\x00\x43\x00\x33\x00\x10\x00\x1a\x00\x36\x00\x37\x00\x38\x00\x04\x00\x31\x00\x3b\x00\x3c\x00\x3d\x00\x03\x00\x44\x00\x44\x00\x38\x00\x07\x00\x22\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x0e\x00\x29\x00\x04\x00\x31\x00\x16\x00\x3e\x00\x2e\x00\x36\x00\x30\x00\x31\x00\x38\x00\x33\x00\x1e\x00\x2e\x00\x36\x00\x37\x00\x38\x00\x32\x00\x00\x00\x3b\x00\x3c\x00\x3d\x00\x37\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x0b\x00\x03\x00\x00\x00\x0e\x00\x36\x00\x07\x00\x0e\x00\x17\x00\x18\x00\x04\x00\x2e\x00\x3b\x00\x0e\x00\x3d\x00\x32\x00\x36\x00\x00\x00\x04\x00\x04\x00\x37\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x17\x00\x18\x00\x36\x00\x01\x00\x36\x00\x03\x00\x36\x00\x22\x00\x0d\x00\x07\x00\x14\x00\x15\x00\x0c\x00\x16\x00\x29\x00\x18\x00\x0e\x00\x40\x00\x04\x00\x2e\x00\x41\x00\x30\x00\x31\x00\x1d\x00\x33\x00\x1d\x00\x2e\x00\x36\x00\x37\x00\x38\x00\x32\x00\x12\x00\x3b\x00\x3c\x00\x3d\x00\x37\x00\x30\x00\x0c\x00\x0d\x00\x04\x00\x34\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x48\x00\x03\x00\x41\x00\x30\x00\x31\x00\x07\x00\x33\x00\x10\x00\x11\x00\x36\x00\x37\x00\x38\x00\x0e\x00\x12\x00\x3b\x00\x3c\x00\x3d\x00\x32\x00\x31\x00\x32\x00\x33\x00\x34\x00\x37\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x0c\x00\x0d\x00\x03\x00\x48\x00\x22\x00\x35\x00\x07\x00\x41\x00\x30\x00\x39\x00\x3a\x00\x29\x00\x34\x00\x0e\x00\x17\x00\x3f\x00\x2e\x00\x0f\x00\x30\x00\x31\x00\x44\x00\x33\x00\x06\x00\x42\x00\x36\x00\x37\x00\x38\x00\x3f\x00\x2f\x00\x3b\x00\x3c\x00\x3d\x00\x1a\x00\x48\x00\x41\x00\x15\x00\x18\x00\x48\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x48\x00\x03\x00\x1a\x00\x30\x00\x31\x00\x07\x00\x33\x00\x41\x00\x48\x00\x36\x00\x37\x00\x38\x00\x0e\x00\x40\x00\x3b\x00\x3c\x00\x3d\x00\x1e\x00\x13\x00\x25\x00\x12\x00\x15\x00\x0f\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x17\x00\x1a\x00\x06\x00\x42\x00\x22\x00\x1d\x00\x3f\x00\x01\x00\x48\x00\x03\x00\x13\x00\x29\x00\x1f\x00\x07\x00\x24\x00\x4d\x00\x2e\x00\x48\x00\x30\x00\x31\x00\x0e\x00\x33\x00\x1b\x00\x4d\x00\x36\x00\x37\x00\x38\x00\x2a\x00\x44\x00\x3b\x00\x3c\x00\x3d\x00\x28\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x01\x00\x26\x00\x03\x00\xff\xff\x29\x00\xff\xff\x07\x00\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x0e\x00\x33\x00\xff\xff\x03\x00\x36\x00\x37\x00\x38\x00\x07\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\x0e\x00\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\x03\x00\xff\xff\x29\x00\xff\xff\x07\x00\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x0e\x00\x33\x00\xff\xff\xff\xff\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\xff\xff\x31\x00\xff\xff\x33\x00\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x3b\x00\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\x3b\x00\xff\xff\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x1b\x00\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x24\x00\x38\x00\x39\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x4d\x00\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\x39\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x02\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x19\x00\x38\x00\xff\xff\x1c\x00\xff\xff\x1e\x00\xff\xff\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x1a\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\xff\xff\xff\xff\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x1a\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x1a\x00\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x1a\x00\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x1a\x00\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\xff\xff\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x1a\x00\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\xff\xff\xff\xff\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x1a\x00\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\xff\xff\xff\xff\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\x1a\x00\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x1a\x00\xff\xff\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x38\x00\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x38\x00\xff\xff\x31\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x38\x00\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x1a\x00\x38\x00\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\x1a\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x1a\x00\xff\xff\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\xff\xff\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x38\x00\x31\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\x38\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x38\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\x38\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
-
-happyTable :: HappyAddr
-happyTable = HappyA# "\x00\x00\x10\x00\x4a\x00\x68\x00\x4b\x00\x65\x00\x6b\x00\x66\x00\x4c\x00\x77\x00\x9b\x00\x09\x00\xbe\x00\x8a\x00\x30\x00\x4d\x00\x83\x00\xcc\x00\x8b\x00\x7e\xff\x0d\x00\x84\x00\x7e\xff\x19\x00\x10\x00\xdc\x00\x0b\x00\xc4\x00\x69\x00\x8c\x00\x0d\x00\x67\x00\x30\x00\x9b\x00\x0e\x00\x4a\x00\x4c\x00\x4b\x00\x5d\x00\x9c\x00\xe4\x00\x4c\x00\x4f\x00\x11\x00\x6b\x00\x72\x00\x9b\x00\x50\x00\x4d\x00\x51\x00\x52\x00\xe3\x00\x53\x00\xca\x00\x60\x00\x54\x00\x55\x00\x56\x00\x5d\x00\x46\x00\x57\x00\x58\x00\x59\x00\x4b\x00\x07\x00\x07\x00\xbc\x00\x4c\x00\x9d\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x4d\x00\x4f\x00\x72\x00\x46\x00\xdf\x00\xc3\x00\x50\x00\x27\x00\x51\x00\x52\x00\x47\x00\x53\x00\xe0\x00\xba\x00\x54\x00\x55\x00\x56\x00\x74\x00\x61\x00\x57\x00\x58\x00\x59\x00\x75\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x4a\x00\x8d\x00\x4b\x00\x61\x00\x8e\x00\x28\x00\x4c\x00\x07\x00\xd0\x00\x63\x00\x72\x00\xbe\x00\x57\x00\x4d\x00\x59\x00\x74\x00\x29\x00\x1a\x00\xc7\x00\x5f\x00\x75\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x62\x00\x63\x00\x2a\x00\x4a\x00\x2b\x00\x4b\x00\x21\x00\x9e\x00\x09\x00\x4c\x00\xdc\x00\xdd\x00\x0b\x00\x1b\x00\x4f\x00\x1c\x00\x4d\x00\xcc\x00\x72\x00\x50\x00\xce\x00\x51\x00\x52\x00\x9b\x00\x53\x00\x9b\x00\x73\x00\x54\x00\x55\x00\x56\x00\x74\x00\x82\x00\x57\x00\x58\x00\x59\x00\x75\x00\xc8\x00\x86\x00\x87\x00\xc7\x00\xe0\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x4a\x00\x5d\x00\x4b\x00\xd6\x00\x51\x00\x52\x00\x4c\x00\x53\x00\xc6\x00\xc7\x00\x54\x00\x55\x00\x56\x00\x4d\x00\x82\x00\x57\x00\x58\x00\x59\x00\x74\x00\x24\x00\x25\x00\x26\x00\x27\x00\xd3\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x86\x00\x87\x00\x4b\x00\x5d\x00\x9f\x00\x1e\x00\x4c\x00\xd8\x00\xc8\x00\x1f\x00\x20\x00\x4f\x00\xc9\x00\x4d\x00\x88\x00\x21\x00\x50\x00\x85\x00\x51\x00\x52\x00\x07\x00\x53\x00\x97\x00\x99\x00\x54\x00\x55\x00\x56\x00\x98\x00\xa6\x00\x57\x00\x58\x00\x59\x00\x89\x00\x5d\x00\xbc\x00\xc0\x00\xc1\x00\x5d\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x4a\x00\x5d\x00\x4b\x00\x89\x00\x51\x00\x52\x00\x4c\x00\x53\x00\xc2\x00\x5d\x00\x54\x00\x55\x00\x56\x00\x4d\x00\xcc\x00\x57\x00\x58\x00\x59\x00\x68\x00\x5f\x00\x7d\x00\x82\x00\x6d\x00\x85\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x88\x00\x89\x00\x97\x00\x99\x00\xa0\x00\x9b\x00\x98\x00\x4a\x00\x5d\x00\x4b\x00\x5f\x00\x4f\x00\x9a\x00\x4c\x00\x23\x00\xff\xff\x50\x00\x5d\x00\x51\x00\x52\x00\x4d\x00\x53\x00\x09\x00\xff\xff\x54\x00\x55\x00\x56\x00\x0b\x00\x07\x00\x57\x00\x58\x00\x59\x00\x10\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x4a\x00\x4e\x00\x4b\x00\x00\x00\x4f\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x50\x00\x00\x00\x51\x00\x52\x00\x4d\x00\x53\x00\x00\x00\x4b\x00\x54\x00\x55\x00\x56\x00\x4c\x00\x00\x00\x57\x00\x58\x00\x59\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x4f\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x50\x00\x00\x00\x51\x00\x52\x00\x4d\x00\x53\x00\x00\x00\x00\x00\x54\x00\x55\x00\x56\x00\x00\x00\x00\x00\x57\x00\x58\x00\x59\x00\x00\x00\x52\x00\x00\x00\x53\x00\x00\x00\x00\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x57\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\xe3\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x09\x00\x45\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x0d\x00\x47\x00\x48\x00\x19\x00\x10\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x1a\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0e\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x31\x00\xe5\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\xf1\xff\x45\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x48\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0e\x00\x00\x00\xe1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\xd9\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x45\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\xda\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x45\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\xd1\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x45\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\xd2\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x45\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\xd6\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x45\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x71\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x45\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x78\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x45\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x45\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\xa1\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\xa4\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\xd8\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\xa7\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\xa9\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\xab\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x8f\x00\x00\x00\xac\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x7b\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x7d\x00\x90\x00\x47\x00\x00\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\x00\x00\x00\x7e\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x7f\x00\x31\x00\x00\x00\x46\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x47\x00\xad\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x31\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\xaf\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x31\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\xb1\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x31\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x00\x00\x6f\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x31\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x00\x00\x00\x00\x6d\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x31\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x00\x00\x00\x00\x77\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x31\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x31\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x47\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\xce\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x47\x00\x00\x00\x46\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x47\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\xd4\x00\x41\x00\x42\x00\x43\x00\x44\x00\x31\x00\x47\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x41\x00\x42\x00\x43\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x31\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x42\x00\x43\x00\x44\x00\x31\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\xb5\x00\x42\x00\x43\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\xb6\x00\x43\x00\x44\x00\x00\x00\x00\x00\x47\x00\x46\x00\xb7\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\x47\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x47\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\xc3\x00\x44\x00\x00\x00\x00\x00\x00\x00\x46\x00\x47\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x46\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
-
-happyReduceArr = Happy_Data_Array.array (5, 142) [
-	(5 , happyReduce_5),
-	(6 , happyReduce_6),
-	(7 , happyReduce_7),
-	(8 , happyReduce_8),
-	(9 , happyReduce_9),
-	(10 , happyReduce_10),
-	(11 , happyReduce_11),
-	(12 , happyReduce_12),
-	(13 , happyReduce_13),
-	(14 , happyReduce_14),
-	(15 , happyReduce_15),
-	(16 , happyReduce_16),
-	(17 , happyReduce_17),
-	(18 , happyReduce_18),
-	(19 , happyReduce_19),
-	(20 , happyReduce_20),
-	(21 , happyReduce_21),
-	(22 , happyReduce_22),
-	(23 , happyReduce_23),
-	(24 , happyReduce_24),
-	(25 , happyReduce_25),
-	(26 , happyReduce_26),
-	(27 , happyReduce_27),
-	(28 , happyReduce_28),
-	(29 , happyReduce_29),
-	(30 , happyReduce_30),
-	(31 , happyReduce_31),
-	(32 , happyReduce_32),
-	(33 , happyReduce_33),
-	(34 , happyReduce_34),
-	(35 , happyReduce_35),
-	(36 , happyReduce_36),
-	(37 , happyReduce_37),
-	(38 , happyReduce_38),
-	(39 , happyReduce_39),
-	(40 , happyReduce_40),
-	(41 , happyReduce_41),
-	(42 , happyReduce_42),
-	(43 , happyReduce_43),
-	(44 , happyReduce_44),
-	(45 , happyReduce_45),
-	(46 , happyReduce_46),
-	(47 , happyReduce_47),
-	(48 , happyReduce_48),
-	(49 , happyReduce_49),
-	(50 , happyReduce_50),
-	(51 , happyReduce_51),
-	(52 , happyReduce_52),
-	(53 , happyReduce_53),
-	(54 , happyReduce_54),
-	(55 , happyReduce_55),
-	(56 , happyReduce_56),
-	(57 , happyReduce_57),
-	(58 , happyReduce_58),
-	(59 , happyReduce_59),
-	(60 , happyReduce_60),
-	(61 , happyReduce_61),
-	(62 , happyReduce_62),
-	(63 , happyReduce_63),
-	(64 , happyReduce_64),
-	(65 , happyReduce_65),
-	(66 , happyReduce_66),
-	(67 , happyReduce_67),
-	(68 , happyReduce_68),
-	(69 , happyReduce_69),
-	(70 , happyReduce_70),
-	(71 , happyReduce_71),
-	(72 , happyReduce_72),
-	(73 , happyReduce_73),
-	(74 , happyReduce_74),
-	(75 , happyReduce_75),
-	(76 , happyReduce_76),
-	(77 , happyReduce_77),
-	(78 , happyReduce_78),
-	(79 , happyReduce_79),
-	(80 , happyReduce_80),
-	(81 , happyReduce_81),
-	(82 , happyReduce_82),
-	(83 , happyReduce_83),
-	(84 , happyReduce_84),
-	(85 , happyReduce_85),
-	(86 , happyReduce_86),
-	(87 , happyReduce_87),
-	(88 , happyReduce_88),
-	(89 , happyReduce_89),
-	(90 , happyReduce_90),
-	(91 , happyReduce_91),
-	(92 , happyReduce_92),
-	(93 , happyReduce_93),
-	(94 , happyReduce_94),
-	(95 , happyReduce_95),
-	(96 , happyReduce_96),
-	(97 , happyReduce_97),
-	(98 , happyReduce_98),
-	(99 , happyReduce_99),
-	(100 , happyReduce_100),
-	(101 , happyReduce_101),
-	(102 , happyReduce_102),
-	(103 , happyReduce_103),
-	(104 , happyReduce_104),
-	(105 , happyReduce_105),
-	(106 , happyReduce_106),
-	(107 , happyReduce_107),
-	(108 , happyReduce_108),
-	(109 , happyReduce_109),
-	(110 , happyReduce_110),
-	(111 , happyReduce_111),
-	(112 , happyReduce_112),
-	(113 , happyReduce_113),
-	(114 , happyReduce_114),
-	(115 , happyReduce_115),
-	(116 , happyReduce_116),
-	(117 , happyReduce_117),
-	(118 , happyReduce_118),
-	(119 , happyReduce_119),
-	(120 , happyReduce_120),
-	(121 , happyReduce_121),
-	(122 , happyReduce_122),
-	(123 , happyReduce_123),
-	(124 , happyReduce_124),
-	(125 , happyReduce_125),
-	(126 , happyReduce_126),
-	(127 , happyReduce_127),
-	(128 , happyReduce_128),
-	(129 , happyReduce_129),
-	(130 , happyReduce_130),
-	(131 , happyReduce_131),
-	(132 , happyReduce_132),
-	(133 , happyReduce_133),
-	(134 , happyReduce_134),
-	(135 , happyReduce_135),
-	(136 , happyReduce_136),
-	(137 , happyReduce_137),
-	(138 , happyReduce_138),
-	(139 , happyReduce_139),
-	(140 , happyReduce_140),
-	(141 , happyReduce_141),
-	(142 , happyReduce_142)
-	]
-
-happy_n_terms = 78 :: Int
-happy_n_nonterms = 58 :: Int
-
-happyReduce_5 = happySpecReduce_1  0# happyReduction_5
-happyReduction_5 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn8
-		 (PosInteger (mkPosToken happy_var_1)
-	)}
-
-happyReduce_6 = happySpecReduce_1  1# happyReduction_6
-happyReduction_6 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn9
-		 (PosDouble (mkPosToken happy_var_1)
-	)}
-
-happyReduce_7 = happySpecReduce_1  2# happyReduction_7
-happyReduction_7 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn10
-		 (PosReal (mkPosToken happy_var_1)
-	)}
-
-happyReduce_8 = happySpecReduce_1  3# happyReduction_8
-happyReduction_8 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn11
-		 (PosString (mkPosToken happy_var_1)
-	)}
-
-happyReduce_9 = happySpecReduce_1  4# happyReduction_9
-happyReduction_9 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn12
-		 (PosIdent (mkPosToken happy_var_1)
-	)}
-
-happyReduce_10 = happySpecReduce_1  5# happyReduction_10
-happyReduction_10 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn13
-		 (PosLineComment (mkPosToken happy_var_1)
-	)}
-
-happyReduce_11 = happySpecReduce_1  6# happyReduction_11
-happyReduction_11 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn14
-		 (PosBlockComment (mkPosToken happy_var_1)
-	)}
-
-happyReduce_12 = happySpecReduce_1  7# happyReduction_12
-happyReduction_12 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn15
-		 (PosAlloy (mkPosToken happy_var_1)
-	)}
-
-happyReduce_13 = happySpecReduce_1  8# happyReduction_13
-happyReduction_13 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn16
-		 (PosChoco (mkPosToken happy_var_1)
-	)}
-
-happyReduce_14 = happySpecReduce_1  9# happyReduction_14
-happyReduction_14 happy_x_1
-	 =  case happyOut59 happy_x_1 of { happy_var_1 -> 
-	happyIn17
-		 (Language.Clafer.Front.AbsClafer.Module ((mkCatSpan happy_var_1)) (reverse happy_var_1)
-	)}
-
-happyReduce_15 = happyReduce 4# 10# happyReduction_15
-happyReduction_15 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut12 happy_x_2 of { happy_var_2 -> 
-	case happyOutTok happy_x_3 of { happy_var_3 -> 
-	case happyOut60 happy_x_4 of { happy_var_4 -> 
-	happyIn18
-		 (Language.Clafer.Front.AbsClafer.EnumDecl ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_4
-	) `HappyStk` happyRest}}}}
-
-happyReduce_16 = happySpecReduce_1  10# happyReduction_16
-happyReduction_16 happy_x_1
-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> 
-	happyIn18
-		 (Language.Clafer.Front.AbsClafer.ElementDecl ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_17 = happyReduce 8# 11# happyReduction_17
-happyReduction_17 (happy_x_8 `HappyStk`
-	happy_x_7 `HappyStk`
-	happy_x_6 `HappyStk`
-	happy_x_5 `HappyStk`
-	happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOut23 happy_x_1 of { happy_var_1 -> 
-	case happyOut30 happy_x_2 of { happy_var_2 -> 
-	case happyOut12 happy_x_3 of { happy_var_3 -> 
-	case happyOut26 happy_x_4 of { happy_var_4 -> 
-	case happyOut27 happy_x_5 of { happy_var_5 -> 
-	case happyOut31 happy_x_6 of { happy_var_6 -> 
-	case happyOut28 happy_x_7 of { happy_var_7 -> 
-	case happyOut24 happy_x_8 of { happy_var_8 -> 
-	happyIn19
-		 (Language.Clafer.Front.AbsClafer.Clafer ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkCatSpan happy_var_4) >- (mkCatSpan happy_var_5) >- (mkCatSpan happy_var_6) >- (mkCatSpan happy_var_7) >- (mkCatSpan happy_var_8)) happy_var_1 happy_var_2 happy_var_3 happy_var_4 happy_var_5 happy_var_6 happy_var_7 happy_var_8
-	) `HappyStk` happyRest}}}}}}}}
-
-happyReduce_18 = happySpecReduce_3  12# happyReduction_18
-happyReduction_18 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut62 happy_x_2 of { happy_var_2 -> 
-	case happyOutTok happy_x_3 of { happy_var_3 -> 
-	happyIn20
-		 (Language.Clafer.Front.AbsClafer.Constraint ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3)) (reverse happy_var_2)
-	)}}}
-
-happyReduce_19 = happyReduce 4# 13# happyReduction_19
-happyReduction_19 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut62 happy_x_3 of { happy_var_3 -> 
-	case happyOutTok happy_x_4 of { happy_var_4 -> 
-	happyIn21
-		 (Language.Clafer.Front.AbsClafer.Assertion ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4)) (reverse happy_var_3)
-	) `HappyStk` happyRest}}}}
-
-happyReduce_20 = happyReduce 4# 14# happyReduction_20
-happyReduction_20 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut62 happy_x_3 of { happy_var_3 -> 
-	case happyOutTok happy_x_4 of { happy_var_4 -> 
-	happyIn22
-		 (Language.Clafer.Front.AbsClafer.GoalMinDeprecated ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4)) (reverse happy_var_3)
-	) `HappyStk` happyRest}}}}
-
-happyReduce_21 = happyReduce 4# 14# happyReduction_21
-happyReduction_21 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut62 happy_x_3 of { happy_var_3 -> 
-	case happyOutTok happy_x_4 of { happy_var_4 -> 
-	happyIn22
-		 (Language.Clafer.Front.AbsClafer.GoalMaxDeprecated ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4)) (reverse happy_var_3)
-	) `HappyStk` happyRest}}}}
-
-happyReduce_22 = happyReduce 4# 14# happyReduction_22
-happyReduction_22 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut62 happy_x_3 of { happy_var_3 -> 
-	case happyOutTok happy_x_4 of { happy_var_4 -> 
-	happyIn22
-		 (Language.Clafer.Front.AbsClafer.GoalMinimize ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4)) (reverse happy_var_3)
-	) `HappyStk` happyRest}}}}
-
-happyReduce_23 = happyReduce 4# 14# happyReduction_23
-happyReduction_23 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut62 happy_x_3 of { happy_var_3 -> 
-	case happyOutTok happy_x_4 of { happy_var_4 -> 
-	happyIn22
-		 (Language.Clafer.Front.AbsClafer.GoalMaximize ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4)) (reverse happy_var_3)
-	) `HappyStk` happyRest}}}}
-
-happyReduce_24 = happySpecReduce_0  15# happyReduction_24
-happyReduction_24  =  happyIn23
-		 (Language.Clafer.Front.AbsClafer.AbstractEmpty noSpan
-	)
-
-happyReduce_25 = happySpecReduce_1  15# happyReduction_25
-happyReduction_25 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn23
-		 (Language.Clafer.Front.AbsClafer.Abstract ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_26 = happySpecReduce_0  16# happyReduction_26
-happyReduction_26  =  happyIn24
-		 (Language.Clafer.Front.AbsClafer.ElementsEmpty noSpan
-	)
-
-happyReduce_27 = happySpecReduce_3  16# happyReduction_27
-happyReduction_27 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut61 happy_x_2 of { happy_var_2 -> 
-	case happyOutTok happy_x_3 of { happy_var_3 -> 
-	happyIn24
-		 (Language.Clafer.Front.AbsClafer.ElementsList ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3)) (reverse happy_var_2)
-	)}}}
-
-happyReduce_28 = happySpecReduce_1  17# happyReduction_28
-happyReduction_28 happy_x_1
-	 =  case happyOut19 happy_x_1 of { happy_var_1 -> 
-	happyIn25
-		 (Language.Clafer.Front.AbsClafer.Subclafer ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_29 = happyReduce 4# 17# happyReduction_29
-happyReduction_29 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut34 happy_x_2 of { happy_var_2 -> 
-	case happyOut31 happy_x_3 of { happy_var_3 -> 
-	case happyOut24 happy_x_4 of { happy_var_4 -> 
-	happyIn25
-		 (Language.Clafer.Front.AbsClafer.ClaferUse ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_3 happy_var_4
-	) `HappyStk` happyRest}}}}
-
-happyReduce_30 = happySpecReduce_1  17# happyReduction_30
-happyReduction_30 happy_x_1
-	 =  case happyOut20 happy_x_1 of { happy_var_1 -> 
-	happyIn25
-		 (Language.Clafer.Front.AbsClafer.Subconstraint ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_31 = happySpecReduce_1  17# happyReduction_31
-happyReduction_31 happy_x_1
-	 =  case happyOut22 happy_x_1 of { happy_var_1 -> 
-	happyIn25
-		 (Language.Clafer.Front.AbsClafer.Subgoal ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_32 = happySpecReduce_1  17# happyReduction_32
-happyReduction_32 happy_x_1
-	 =  case happyOut21 happy_x_1 of { happy_var_1 -> 
-	happyIn25
-		 (Language.Clafer.Front.AbsClafer.SubAssertion ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_33 = happySpecReduce_0  18# happyReduction_33
-happyReduction_33  =  happyIn26
-		 (Language.Clafer.Front.AbsClafer.SuperEmpty noSpan
-	)
-
-happyReduce_34 = happySpecReduce_2  18# happyReduction_34
-happyReduction_34 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut52 happy_x_2 of { happy_var_2 -> 
-	happyIn26
-		 (Language.Clafer.Front.AbsClafer.SuperSome ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
-	)}}
-
-happyReduce_35 = happySpecReduce_0  19# happyReduction_35
-happyReduction_35  =  happyIn27
-		 (Language.Clafer.Front.AbsClafer.ReferenceEmpty noSpan
-	)
-
-happyReduce_36 = happySpecReduce_2  19# happyReduction_36
-happyReduction_36 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut49 happy_x_2 of { happy_var_2 -> 
-	happyIn27
-		 (Language.Clafer.Front.AbsClafer.ReferenceSet ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
-	)}}
-
-happyReduce_37 = happySpecReduce_2  19# happyReduction_37
-happyReduction_37 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut49 happy_x_2 of { happy_var_2 -> 
-	happyIn27
-		 (Language.Clafer.Front.AbsClafer.ReferenceBag ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
-	)}}
-
-happyReduce_38 = happySpecReduce_0  20# happyReduction_38
-happyReduction_38  =  happyIn28
-		 (Language.Clafer.Front.AbsClafer.InitEmpty noSpan
-	)
-
-happyReduce_39 = happySpecReduce_2  20# happyReduction_39
-happyReduction_39 happy_x_2
-	happy_x_1
-	 =  case happyOut29 happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_2 of { happy_var_2 -> 
-	happyIn28
-		 (Language.Clafer.Front.AbsClafer.InitSome ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_1 happy_var_2
-	)}}
-
-happyReduce_40 = happySpecReduce_1  21# happyReduction_40
-happyReduction_40 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn29
-		 (Language.Clafer.Front.AbsClafer.InitConstant ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_41 = happySpecReduce_1  21# happyReduction_41
-happyReduction_41 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn29
-		 (Language.Clafer.Front.AbsClafer.InitDefault ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_42 = happySpecReduce_0  22# happyReduction_42
-happyReduction_42  =  happyIn30
-		 (Language.Clafer.Front.AbsClafer.GCardEmpty noSpan
-	)
-
-happyReduce_43 = happySpecReduce_1  22# happyReduction_43
-happyReduction_43 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn30
-		 (Language.Clafer.Front.AbsClafer.GCardXor ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_44 = happySpecReduce_1  22# happyReduction_44
-happyReduction_44 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn30
-		 (Language.Clafer.Front.AbsClafer.GCardOr ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_45 = happySpecReduce_1  22# happyReduction_45
-happyReduction_45 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn30
-		 (Language.Clafer.Front.AbsClafer.GCardMux ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_46 = happySpecReduce_1  22# happyReduction_46
-happyReduction_46 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn30
-		 (Language.Clafer.Front.AbsClafer.GCardOpt ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_47 = happySpecReduce_1  22# happyReduction_47
-happyReduction_47 happy_x_1
-	 =  case happyOut32 happy_x_1 of { happy_var_1 -> 
-	happyIn30
-		 (Language.Clafer.Front.AbsClafer.GCardInterval ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_48 = happySpecReduce_0  23# happyReduction_48
-happyReduction_48  =  happyIn31
-		 (Language.Clafer.Front.AbsClafer.CardEmpty noSpan
-	)
-
-happyReduce_49 = happySpecReduce_1  23# happyReduction_49
-happyReduction_49 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn31
-		 (Language.Clafer.Front.AbsClafer.CardLone ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_50 = happySpecReduce_1  23# happyReduction_50
-happyReduction_50 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn31
-		 (Language.Clafer.Front.AbsClafer.CardSome ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_51 = happySpecReduce_1  23# happyReduction_51
-happyReduction_51 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn31
-		 (Language.Clafer.Front.AbsClafer.CardAny ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_52 = happySpecReduce_1  23# happyReduction_52
-happyReduction_52 happy_x_1
-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> 
-	happyIn31
-		 (Language.Clafer.Front.AbsClafer.CardNum ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_53 = happySpecReduce_1  23# happyReduction_53
-happyReduction_53 happy_x_1
-	 =  case happyOut32 happy_x_1 of { happy_var_1 -> 
-	happyIn31
-		 (Language.Clafer.Front.AbsClafer.CardInterval ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_54 = happySpecReduce_3  24# happyReduction_54
-happyReduction_54 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut33 happy_x_3 of { happy_var_3 -> 
-	happyIn32
-		 (Language.Clafer.Front.AbsClafer.NCard ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_55 = happySpecReduce_1  25# happyReduction_55
-happyReduction_55 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn33
-		 (Language.Clafer.Front.AbsClafer.ExIntegerAst ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_56 = happySpecReduce_1  25# happyReduction_56
-happyReduction_56 happy_x_1
-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> 
-	happyIn33
-		 (Language.Clafer.Front.AbsClafer.ExIntegerNum ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_57 = happySpecReduce_1  26# happyReduction_57
-happyReduction_57 happy_x_1
-	 =  case happyOut64 happy_x_1 of { happy_var_1 -> 
-	happyIn34
-		 (Language.Clafer.Front.AbsClafer.Path ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_58 = happyReduce 5# 27# happyReduction_58
-happyReduction_58 (happy_x_5 `HappyStk`
-	happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut54 happy_x_3 of { happy_var_3 -> 
-	case happyOutTok happy_x_4 of { happy_var_4 -> 
-	case happyOut35 happy_x_5 of { happy_var_5 -> 
-	happyIn35
-		 (Language.Clafer.Front.AbsClafer.EDeclAllDisj ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4) >- (mkCatSpan happy_var_5)) happy_var_3 happy_var_5
-	) `HappyStk` happyRest}}}}}
-
-happyReduce_59 = happyReduce 4# 27# happyReduction_59
-happyReduction_59 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut54 happy_x_2 of { happy_var_2 -> 
-	case happyOutTok happy_x_3 of { happy_var_3 -> 
-	case happyOut35 happy_x_4 of { happy_var_4 -> 
-	happyIn35
-		 (Language.Clafer.Front.AbsClafer.EDeclAll ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_4
-	) `HappyStk` happyRest}}}}
-
-happyReduce_60 = happyReduce 5# 27# happyReduction_60
-happyReduction_60 (happy_x_5 `HappyStk`
-	happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOut55 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut54 happy_x_3 of { happy_var_3 -> 
-	case happyOutTok happy_x_4 of { happy_var_4 -> 
-	case happyOut35 happy_x_5 of { happy_var_5 -> 
-	happyIn35
-		 (Language.Clafer.Front.AbsClafer.EDeclQuantDisj ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4) >- (mkCatSpan happy_var_5)) happy_var_1 happy_var_3 happy_var_5
-	) `HappyStk` happyRest}}}}}
-
-happyReduce_61 = happyReduce 4# 27# happyReduction_61
-happyReduction_61 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOut55 happy_x_1 of { happy_var_1 -> 
-	case happyOut54 happy_x_2 of { happy_var_2 -> 
-	case happyOutTok happy_x_3 of { happy_var_3 -> 
-	case happyOut35 happy_x_4 of { happy_var_4 -> 
-	happyIn35
-		 (Language.Clafer.Front.AbsClafer.EDeclQuant ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_1 happy_var_2 happy_var_4
-	) `HappyStk` happyRest}}}}
-
-happyReduce_62 = happyReduce 6# 27# happyReduction_62
-happyReduction_62 (happy_x_6 `HappyStk`
-	happy_x_5 `HappyStk`
-	happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_2 of { happy_var_2 -> 
-	case happyOutTok happy_x_3 of { happy_var_3 -> 
-	case happyOut35 happy_x_4 of { happy_var_4 -> 
-	case happyOutTok happy_x_5 of { happy_var_5 -> 
-	case happyOut35 happy_x_6 of { happy_var_6 -> 
-	happyIn35
-		 (Language.Clafer.Front.AbsClafer.EImpliesElse ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4) >- (mkTokenSpan happy_var_5) >- (mkCatSpan happy_var_6)) happy_var_2 happy_var_4 happy_var_6
-	) `HappyStk` happyRest}}}}}}
-
-happyReduce_63 = happySpecReduce_3  27# happyReduction_63
-happyReduction_63 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut35 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut65 happy_x_3 of { happy_var_3 -> 
-	happyIn35
-		 (Language.Clafer.Front.AbsClafer.EIff ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_64 = happySpecReduce_1  27# happyReduction_64
-happyReduction_64 happy_x_1
-	 =  case happyOut65 happy_x_1 of { happy_var_1 -> 
-	happyIn35
-		 (happy_var_1
-	)}
-
-happyReduce_65 = happySpecReduce_3  28# happyReduction_65
-happyReduction_65 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut36 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut37 happy_x_3 of { happy_var_3 -> 
-	happyIn36
-		 (Language.Clafer.Front.AbsClafer.EImplies ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_66 = happySpecReduce_1  28# happyReduction_66
-happyReduction_66 happy_x_1
-	 =  case happyOut37 happy_x_1 of { happy_var_1 -> 
-	happyIn36
-		 (happy_var_1
-	)}
-
-happyReduce_67 = happySpecReduce_3  29# happyReduction_67
-happyReduction_67 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut37 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut38 happy_x_3 of { happy_var_3 -> 
-	happyIn37
-		 (Language.Clafer.Front.AbsClafer.EOr ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_68 = happySpecReduce_1  29# happyReduction_68
-happyReduction_68 happy_x_1
-	 =  case happyOut38 happy_x_1 of { happy_var_1 -> 
-	happyIn37
-		 (happy_var_1
-	)}
-
-happyReduce_69 = happySpecReduce_3  30# happyReduction_69
-happyReduction_69 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut38 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut39 happy_x_3 of { happy_var_3 -> 
-	happyIn38
-		 (Language.Clafer.Front.AbsClafer.EXor ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_70 = happySpecReduce_1  30# happyReduction_70
-happyReduction_70 happy_x_1
-	 =  case happyOut39 happy_x_1 of { happy_var_1 -> 
-	happyIn38
-		 (happy_var_1
-	)}
-
-happyReduce_71 = happySpecReduce_3  31# happyReduction_71
-happyReduction_71 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut39 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut40 happy_x_3 of { happy_var_3 -> 
-	happyIn39
-		 (Language.Clafer.Front.AbsClafer.EAnd ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_72 = happySpecReduce_1  31# happyReduction_72
-happyReduction_72 happy_x_1
-	 =  case happyOut40 happy_x_1 of { happy_var_1 -> 
-	happyIn39
-		 (happy_var_1
-	)}
-
-happyReduce_73 = happySpecReduce_2  32# happyReduction_73
-happyReduction_73 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut41 happy_x_2 of { happy_var_2 -> 
-	happyIn40
-		 (Language.Clafer.Front.AbsClafer.ENeg ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
-	)}}
-
-happyReduce_74 = happySpecReduce_1  32# happyReduction_74
-happyReduction_74 happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	happyIn40
-		 (happy_var_1
-	)}
-
-happyReduce_75 = happySpecReduce_3  33# happyReduction_75
-happyReduction_75 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut42 happy_x_3 of { happy_var_3 -> 
-	happyIn41
-		 (Language.Clafer.Front.AbsClafer.ELt ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_76 = happySpecReduce_3  33# happyReduction_76
-happyReduction_76 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut42 happy_x_3 of { happy_var_3 -> 
-	happyIn41
-		 (Language.Clafer.Front.AbsClafer.EGt ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_77 = happySpecReduce_3  33# happyReduction_77
-happyReduction_77 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut42 happy_x_3 of { happy_var_3 -> 
-	happyIn41
-		 (Language.Clafer.Front.AbsClafer.EEq ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_78 = happySpecReduce_3  33# happyReduction_78
-happyReduction_78 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut42 happy_x_3 of { happy_var_3 -> 
-	happyIn41
-		 (Language.Clafer.Front.AbsClafer.ELte ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_79 = happySpecReduce_3  33# happyReduction_79
-happyReduction_79 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut42 happy_x_3 of { happy_var_3 -> 
-	happyIn41
-		 (Language.Clafer.Front.AbsClafer.EGte ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_80 = happySpecReduce_3  33# happyReduction_80
-happyReduction_80 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut42 happy_x_3 of { happy_var_3 -> 
-	happyIn41
-		 (Language.Clafer.Front.AbsClafer.ENeq ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_81 = happySpecReduce_3  33# happyReduction_81
-happyReduction_81 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut42 happy_x_3 of { happy_var_3 -> 
-	happyIn41
-		 (Language.Clafer.Front.AbsClafer.EIn ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_82 = happyReduce 4# 33# happyReduction_82
-happyReduction_82 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOut41 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOutTok happy_x_3 of { happy_var_3 -> 
-	case happyOut42 happy_x_4 of { happy_var_4 -> 
-	happyIn41
-		 (Language.Clafer.Front.AbsClafer.ENin ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_1 happy_var_4
-	) `HappyStk` happyRest}}}}
-
-happyReduce_83 = happySpecReduce_1  33# happyReduction_83
-happyReduction_83 happy_x_1
-	 =  case happyOut42 happy_x_1 of { happy_var_1 -> 
-	happyIn41
-		 (happy_var_1
-	)}
-
-happyReduce_84 = happySpecReduce_2  34# happyReduction_84
-happyReduction_84 happy_x_2
-	happy_x_1
-	 =  case happyOut55 happy_x_1 of { happy_var_1 -> 
-	case happyOut46 happy_x_2 of { happy_var_2 -> 
-	happyIn42
-		 (Language.Clafer.Front.AbsClafer.EQuantExp ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_1 happy_var_2
-	)}}
-
-happyReduce_85 = happySpecReduce_1  34# happyReduction_85
-happyReduction_85 happy_x_1
-	 =  case happyOut43 happy_x_1 of { happy_var_1 -> 
-	happyIn42
-		 (happy_var_1
-	)}
-
-happyReduce_86 = happySpecReduce_3  35# happyReduction_86
-happyReduction_86 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut43 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut44 happy_x_3 of { happy_var_3 -> 
-	happyIn43
-		 (Language.Clafer.Front.AbsClafer.EAdd ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_87 = happySpecReduce_3  35# happyReduction_87
-happyReduction_87 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut43 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut44 happy_x_3 of { happy_var_3 -> 
-	happyIn43
-		 (Language.Clafer.Front.AbsClafer.ESub ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_88 = happySpecReduce_1  35# happyReduction_88
-happyReduction_88 happy_x_1
-	 =  case happyOut44 happy_x_1 of { happy_var_1 -> 
-	happyIn43
-		 (happy_var_1
-	)}
-
-happyReduce_89 = happySpecReduce_3  36# happyReduction_89
-happyReduction_89 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut44 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut45 happy_x_3 of { happy_var_3 -> 
-	happyIn44
-		 (Language.Clafer.Front.AbsClafer.EMul ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_90 = happySpecReduce_3  36# happyReduction_90
-happyReduction_90 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut44 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut45 happy_x_3 of { happy_var_3 -> 
-	happyIn44
-		 (Language.Clafer.Front.AbsClafer.EDiv ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_91 = happySpecReduce_3  36# happyReduction_91
-happyReduction_91 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut44 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut45 happy_x_3 of { happy_var_3 -> 
-	happyIn44
-		 (Language.Clafer.Front.AbsClafer.ERem ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_92 = happySpecReduce_1  36# happyReduction_92
-happyReduction_92 happy_x_1
-	 =  case happyOut45 happy_x_1 of { happy_var_1 -> 
-	happyIn44
-		 (happy_var_1
-	)}
-
-happyReduce_93 = happySpecReduce_2  37# happyReduction_93
-happyReduction_93 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut46 happy_x_2 of { happy_var_2 -> 
-	happyIn45
-		 (Language.Clafer.Front.AbsClafer.EGMax ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
-	)}}
-
-happyReduce_94 = happySpecReduce_2  37# happyReduction_94
-happyReduction_94 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut46 happy_x_2 of { happy_var_2 -> 
-	happyIn45
-		 (Language.Clafer.Front.AbsClafer.EGMin ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
-	)}}
-
-happyReduce_95 = happySpecReduce_1  37# happyReduction_95
-happyReduction_95 happy_x_1
-	 =  case happyOut46 happy_x_1 of { happy_var_1 -> 
-	happyIn45
-		 (happy_var_1
-	)}
-
-happyReduce_96 = happySpecReduce_2  38# happyReduction_96
-happyReduction_96 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut47 happy_x_2 of { happy_var_2 -> 
-	happyIn46
-		 (Language.Clafer.Front.AbsClafer.ESum ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
-	)}}
-
-happyReduce_97 = happySpecReduce_2  38# happyReduction_97
-happyReduction_97 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut47 happy_x_2 of { happy_var_2 -> 
-	happyIn46
-		 (Language.Clafer.Front.AbsClafer.EProd ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
-	)}}
-
-happyReduce_98 = happySpecReduce_2  38# happyReduction_98
-happyReduction_98 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut47 happy_x_2 of { happy_var_2 -> 
-	happyIn46
-		 (Language.Clafer.Front.AbsClafer.ECard ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
-	)}}
-
-happyReduce_99 = happySpecReduce_2  38# happyReduction_99
-happyReduction_99 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut47 happy_x_2 of { happy_var_2 -> 
-	happyIn46
-		 (Language.Clafer.Front.AbsClafer.EMinExp ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
-	)}}
-
-happyReduce_100 = happySpecReduce_1  38# happyReduction_100
-happyReduction_100 happy_x_1
-	 =  case happyOut47 happy_x_1 of { happy_var_1 -> 
-	happyIn46
-		 (happy_var_1
-	)}
-
-happyReduce_101 = happySpecReduce_3  39# happyReduction_101
-happyReduction_101 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut47 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut48 happy_x_3 of { happy_var_3 -> 
-	happyIn47
-		 (Language.Clafer.Front.AbsClafer.EDomain ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_102 = happySpecReduce_1  39# happyReduction_102
-happyReduction_102 happy_x_1
-	 =  case happyOut48 happy_x_1 of { happy_var_1 -> 
-	happyIn47
-		 (happy_var_1
-	)}
-
-happyReduce_103 = happySpecReduce_3  40# happyReduction_103
-happyReduction_103 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut48 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut49 happy_x_3 of { happy_var_3 -> 
-	happyIn48
-		 (Language.Clafer.Front.AbsClafer.ERange ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_104 = happySpecReduce_1  40# happyReduction_104
-happyReduction_104 happy_x_1
-	 =  case happyOut49 happy_x_1 of { happy_var_1 -> 
-	happyIn48
-		 (happy_var_1
-	)}
-
-happyReduce_105 = happySpecReduce_3  41# happyReduction_105
-happyReduction_105 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut49 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut50 happy_x_3 of { happy_var_3 -> 
-	happyIn49
-		 (Language.Clafer.Front.AbsClafer.EUnion ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_106 = happySpecReduce_3  41# happyReduction_106
-happyReduction_106 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut49 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut50 happy_x_3 of { happy_var_3 -> 
-	happyIn49
-		 (Language.Clafer.Front.AbsClafer.EUnionCom ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_107 = happySpecReduce_1  41# happyReduction_107
-happyReduction_107 happy_x_1
-	 =  case happyOut50 happy_x_1 of { happy_var_1 -> 
-	happyIn49
-		 (happy_var_1
-	)}
-
-happyReduce_108 = happySpecReduce_3  42# happyReduction_108
-happyReduction_108 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut50 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut51 happy_x_3 of { happy_var_3 -> 
-	happyIn50
-		 (Language.Clafer.Front.AbsClafer.EDifference ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_109 = happySpecReduce_1  42# happyReduction_109
-happyReduction_109 happy_x_1
-	 =  case happyOut51 happy_x_1 of { happy_var_1 -> 
-	happyIn50
-		 (happy_var_1
-	)}
-
-happyReduce_110 = happySpecReduce_3  43# happyReduction_110
-happyReduction_110 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut51 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut52 happy_x_3 of { happy_var_3 -> 
-	happyIn51
-		 (Language.Clafer.Front.AbsClafer.EIntersection ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_111 = happySpecReduce_3  43# happyReduction_111
-happyReduction_111 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut51 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut52 happy_x_3 of { happy_var_3 -> 
-	happyIn51
-		 (Language.Clafer.Front.AbsClafer.EIntersectionDeprecated ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_112 = happySpecReduce_1  43# happyReduction_112
-happyReduction_112 happy_x_1
-	 =  case happyOut52 happy_x_1 of { happy_var_1 -> 
-	happyIn51
-		 (happy_var_1
-	)}
-
-happyReduce_113 = happySpecReduce_3  44# happyReduction_113
-happyReduction_113 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut52 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut53 happy_x_3 of { happy_var_3 -> 
-	happyIn52
-		 (Language.Clafer.Front.AbsClafer.EJoin ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_114 = happySpecReduce_1  44# happyReduction_114
-happyReduction_114 happy_x_1
-	 =  case happyOut53 happy_x_1 of { happy_var_1 -> 
-	happyIn52
-		 (happy_var_1
-	)}
-
-happyReduce_115 = happySpecReduce_1  45# happyReduction_115
-happyReduction_115 happy_x_1
-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> 
-	happyIn53
-		 (Language.Clafer.Front.AbsClafer.ClaferId ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_116 = happySpecReduce_1  45# happyReduction_116
-happyReduction_116 happy_x_1
-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> 
-	happyIn53
-		 (Language.Clafer.Front.AbsClafer.EInt ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_117 = happySpecReduce_1  45# happyReduction_117
-happyReduction_117 happy_x_1
-	 =  case happyOut9 happy_x_1 of { happy_var_1 -> 
-	happyIn53
-		 (Language.Clafer.Front.AbsClafer.EDouble ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_118 = happySpecReduce_1  45# happyReduction_118
-happyReduction_118 happy_x_1
-	 =  case happyOut10 happy_x_1 of { happy_var_1 -> 
-	happyIn53
-		 (Language.Clafer.Front.AbsClafer.EReal ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_119 = happySpecReduce_1  45# happyReduction_119
-happyReduction_119 happy_x_1
-	 =  case happyOut11 happy_x_1 of { happy_var_1 -> 
-	happyIn53
-		 (Language.Clafer.Front.AbsClafer.EStr ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_120 = happySpecReduce_3  45# happyReduction_120
-happyReduction_120 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut35 happy_x_2 of { happy_var_2 -> 
-	happyIn53
-		 (happy_var_2
-	)}
-
-happyReduce_121 = happySpecReduce_3  46# happyReduction_121
-happyReduction_121 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut63 happy_x_1 of { happy_var_1 -> 
-	case happyOutTok happy_x_2 of { happy_var_2 -> 
-	case happyOut49 happy_x_3 of { happy_var_3 -> 
-	happyIn54
-		 (Language.Clafer.Front.AbsClafer.Decl ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
-	)}}}
-
-happyReduce_122 = happySpecReduce_1  47# happyReduction_122
-happyReduction_122 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn55
-		 (Language.Clafer.Front.AbsClafer.QuantNo ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_123 = happySpecReduce_1  47# happyReduction_123
-happyReduction_123 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn55
-		 (Language.Clafer.Front.AbsClafer.QuantNot ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_124 = happySpecReduce_1  47# happyReduction_124
-happyReduction_124 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn55
-		 (Language.Clafer.Front.AbsClafer.QuantLone ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_125 = happySpecReduce_1  47# happyReduction_125
-happyReduction_125 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn55
-		 (Language.Clafer.Front.AbsClafer.QuantOne ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_126 = happySpecReduce_1  47# happyReduction_126
-happyReduction_126 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn55
-		 (Language.Clafer.Front.AbsClafer.QuantSome ((mkTokenSpan happy_var_1))
-	)}
-
-happyReduce_127 = happySpecReduce_1  48# happyReduction_127
-happyReduction_127 happy_x_1
-	 =  case happyOut12 happy_x_1 of { happy_var_1 -> 
-	happyIn56
-		 (Language.Clafer.Front.AbsClafer.EnumIdIdent ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_128 = happySpecReduce_1  49# happyReduction_128
-happyReduction_128 happy_x_1
-	 =  case happyOut12 happy_x_1 of { happy_var_1 -> 
-	happyIn57
-		 (Language.Clafer.Front.AbsClafer.ModIdIdent ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_129 = happySpecReduce_1  50# happyReduction_129
-happyReduction_129 happy_x_1
-	 =  case happyOut12 happy_x_1 of { happy_var_1 -> 
-	happyIn58
-		 (Language.Clafer.Front.AbsClafer.LocIdIdent ((mkCatSpan happy_var_1)) happy_var_1
-	)}
-
-happyReduce_130 = happySpecReduce_0  51# happyReduction_130
-happyReduction_130  =  happyIn59
-		 ([]
-	)
-
-happyReduce_131 = happySpecReduce_2  51# happyReduction_131
-happyReduction_131 happy_x_2
-	happy_x_1
-	 =  case happyOut59 happy_x_1 of { happy_var_1 -> 
-	case happyOut18 happy_x_2 of { happy_var_2 -> 
-	happyIn59
-		 (flip (:)  happy_var_1 happy_var_2
-	)}}
-
-happyReduce_132 = happySpecReduce_1  52# happyReduction_132
-happyReduction_132 happy_x_1
-	 =  case happyOut56 happy_x_1 of { happy_var_1 -> 
-	happyIn60
-		 ((:[])  happy_var_1
-	)}
-
-happyReduce_133 = happySpecReduce_3  52# happyReduction_133
-happyReduction_133 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut56 happy_x_1 of { happy_var_1 -> 
-	case happyOut60 happy_x_3 of { happy_var_3 -> 
-	happyIn60
-		 ((:)  happy_var_1 happy_var_3
-	)}}
-
-happyReduce_134 = happySpecReduce_0  53# happyReduction_134
-happyReduction_134  =  happyIn61
-		 ([]
-	)
-
-happyReduce_135 = happySpecReduce_2  53# happyReduction_135
-happyReduction_135 happy_x_2
-	happy_x_1
-	 =  case happyOut61 happy_x_1 of { happy_var_1 -> 
-	case happyOut25 happy_x_2 of { happy_var_2 -> 
-	happyIn61
-		 (flip (:)  happy_var_1 happy_var_2
-	)}}
-
-happyReduce_136 = happySpecReduce_0  54# happyReduction_136
-happyReduction_136  =  happyIn62
-		 ([]
-	)
-
-happyReduce_137 = happySpecReduce_2  54# happyReduction_137
-happyReduction_137 happy_x_2
-	happy_x_1
-	 =  case happyOut62 happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_2 of { happy_var_2 -> 
-	happyIn62
-		 (flip (:)  happy_var_1 happy_var_2
-	)}}
-
-happyReduce_138 = happySpecReduce_1  55# happyReduction_138
-happyReduction_138 happy_x_1
-	 =  case happyOut58 happy_x_1 of { happy_var_1 -> 
-	happyIn63
-		 ((:[])  happy_var_1
-	)}
-
-happyReduce_139 = happySpecReduce_3  55# happyReduction_139
-happyReduction_139 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut58 happy_x_1 of { happy_var_1 -> 
-	case happyOut63 happy_x_3 of { happy_var_3 -> 
-	happyIn63
-		 ((:)  happy_var_1 happy_var_3
-	)}}
-
-happyReduce_140 = happySpecReduce_1  56# happyReduction_140
-happyReduction_140 happy_x_1
-	 =  case happyOut57 happy_x_1 of { happy_var_1 -> 
-	happyIn64
-		 ((:[])  happy_var_1
-	)}
-
-happyReduce_141 = happySpecReduce_3  56# happyReduction_141
-happyReduction_141 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut57 happy_x_1 of { happy_var_1 -> 
-	case happyOut64 happy_x_3 of { happy_var_3 -> 
-	happyIn64
-		 ((:)  happy_var_1 happy_var_3
-	)}}
-
-happyReduce_142 = happySpecReduce_1  57# happyReduction_142
-happyReduction_142 happy_x_1
-	 =  case happyOut36 happy_x_1 of { happy_var_1 -> 
-	happyIn65
-		 (happy_var_1
-	)}
-
-happyNewToken action sts stk [] =
-	happyDoAction 77# notHappyAtAll action sts stk []
-
-happyNewToken action sts stk (tk:tks) =
-	let cont i = happyDoAction i tk action sts stk tks in
-	case tk of {
-	PT _ (TS _ 1) -> cont 1#;
-	PT _ (TS _ 2) -> cont 2#;
-	PT _ (TS _ 3) -> cont 3#;
-	PT _ (TS _ 4) -> cont 4#;
-	PT _ (TS _ 5) -> cont 5#;
-	PT _ (TS _ 6) -> cont 6#;
-	PT _ (TS _ 7) -> cont 7#;
-	PT _ (TS _ 8) -> cont 8#;
-	PT _ (TS _ 9) -> cont 9#;
-	PT _ (TS _ 10) -> cont 10#;
-	PT _ (TS _ 11) -> cont 11#;
-	PT _ (TS _ 12) -> cont 12#;
-	PT _ (TS _ 13) -> cont 13#;
-	PT _ (TS _ 14) -> cont 14#;
-	PT _ (TS _ 15) -> cont 15#;
-	PT _ (TS _ 16) -> cont 16#;
-	PT _ (TS _ 17) -> cont 17#;
-	PT _ (TS _ 18) -> cont 18#;
-	PT _ (TS _ 19) -> cont 19#;
-	PT _ (TS _ 20) -> cont 20#;
-	PT _ (TS _ 21) -> cont 21#;
-	PT _ (TS _ 22) -> cont 22#;
-	PT _ (TS _ 23) -> cont 23#;
-	PT _ (TS _ 24) -> cont 24#;
-	PT _ (TS _ 25) -> cont 25#;
-	PT _ (TS _ 26) -> cont 26#;
-	PT _ (TS _ 27) -> cont 27#;
-	PT _ (TS _ 28) -> cont 28#;
-	PT _ (TS _ 29) -> cont 29#;
-	PT _ (TS _ 30) -> cont 30#;
-	PT _ (TS _ 31) -> cont 31#;
-	PT _ (TS _ 32) -> cont 32#;
-	PT _ (TS _ 33) -> cont 33#;
-	PT _ (TS _ 34) -> cont 34#;
-	PT _ (TS _ 35) -> cont 35#;
-	PT _ (TS _ 36) -> cont 36#;
-	PT _ (TS _ 37) -> cont 37#;
-	PT _ (TS _ 38) -> cont 38#;
-	PT _ (TS _ 39) -> cont 39#;
-	PT _ (TS _ 40) -> cont 40#;
-	PT _ (TS _ 41) -> cont 41#;
-	PT _ (TS _ 42) -> cont 42#;
-	PT _ (TS _ 43) -> cont 43#;
-	PT _ (TS _ 44) -> cont 44#;
-	PT _ (TS _ 45) -> cont 45#;
-	PT _ (TS _ 46) -> cont 46#;
-	PT _ (TS _ 47) -> cont 47#;
-	PT _ (TS _ 48) -> cont 48#;
-	PT _ (TS _ 49) -> cont 49#;
-	PT _ (TS _ 50) -> cont 50#;
-	PT _ (TS _ 51) -> cont 51#;
-	PT _ (TS _ 52) -> cont 52#;
-	PT _ (TS _ 53) -> cont 53#;
-	PT _ (TS _ 54) -> cont 54#;
-	PT _ (TS _ 55) -> cont 55#;
-	PT _ (TS _ 56) -> cont 56#;
-	PT _ (TS _ 57) -> cont 57#;
-	PT _ (TS _ 58) -> cont 58#;
-	PT _ (TS _ 59) -> cont 59#;
-	PT _ (TS _ 60) -> cont 60#;
-	PT _ (TS _ 61) -> cont 61#;
-	PT _ (TS _ 62) -> cont 62#;
-	PT _ (TS _ 63) -> cont 63#;
-	PT _ (TS _ 64) -> cont 64#;
-	PT _ (TS _ 65) -> cont 65#;
-	PT _ (TS _ 66) -> cont 66#;
-	PT _ (TS _ 67) -> cont 67#;
-	PT _ (T_PosInteger _) -> cont 68#;
-	PT _ (T_PosDouble _) -> cont 69#;
-	PT _ (T_PosReal _) -> cont 70#;
-	PT _ (T_PosString _) -> cont 71#;
-	PT _ (T_PosIdent _) -> cont 72#;
-	PT _ (T_PosLineComment _) -> cont 73#;
-	PT _ (T_PosBlockComment _) -> cont 74#;
-	PT _ (T_PosAlloy _) -> cont 75#;
-	PT _ (T_PosChoco _) -> cont 76#;
-	_ -> happyError' (tk:tks)
-	}
-
-happyError_ 77# tk tks = happyError' tks
-happyError_ _ tk tks = happyError' (tk:tks)
-
-happyThen :: () => Err a -> (a -> Err b) -> Err b
-happyThen = (thenM)
-happyReturn :: () => a -> Err a
-happyReturn = (returnM)
-happyThen1 m k tks = (thenM) m (\a -> k a tks)
-happyReturn1 :: () => a -> b -> Err a
-happyReturn1 = \a tks -> (returnM) a
-happyError' :: () => [(Token)] -> Err a
-happyError' = happyError
-
-pModule tks = happySomeParser where
-  happySomeParser = happyThen (happyParse 0# tks) (\x -> happyReturn (happyOut17 x))
-
-pClafer tks = happySomeParser where
-  happySomeParser = happyThen (happyParse 1# tks) (\x -> happyReturn (happyOut19 x))
-
-pConstraint tks = happySomeParser where
-  happySomeParser = happyThen (happyParse 2# tks) (\x -> happyReturn (happyOut20 x))
-
-pAssertion tks = happySomeParser where
-  happySomeParser = happyThen (happyParse 3# tks) (\x -> happyReturn (happyOut21 x))
-
-pGoal tks = happySomeParser where
-  happySomeParser = happyThen (happyParse 4# tks) (\x -> happyReturn (happyOut22 x))
-
-happySeq = happyDontSeq
-
-
-returnM :: a -> Err a
-returnM = return
-
-thenM :: Err a -> (a -> Err b) -> Err b
-thenM = (>>=)
-
-happyError :: [Token] -> Err a
-happyError ts =
-  Bad (pp ts) $ "syntax error at " ++ tokenPos ts ++ 
-  case ts of
-    [] -> []
-    [Err _] -> " due to lexer error"
-    _ -> " before " ++ unwords (map (id . prToken) (take 4 ts))
-
-myLexer = tokens
-
-gp x@(PT (Pn _ l c) _) = Span (Pos (toInteger l) (toInteger c)) (Pos (toInteger l) (toInteger c + toInteger (length $ prToken x)))
-pp (PT (Pn _ l c) _ :_) = Pos (toInteger l) (toInteger c)
-pp (Err (Pn _ l c) :_) = Pos (toInteger l) (toInteger c)
-pp _ = error "EOF"
-
-mkCatSpan :: (Spannable c) => c -> Span
-mkCatSpan = getSpan
-
-mkTokenSpan :: Token -> Span
-mkTokenSpan = gp
-{-# LINE 1 "templates\GenericTemplate.hs" #-}
-{-# LINE 1 "templates\\GenericTemplate.hs" #-}
-{-# LINE 1 "<built-in>" #-}
-{-# LINE 1 "<command-line>" #-}
-{-# LINE 12 "<command-line>" #-}
-{-# LINE 1 "C:\\Users\\mantkiew\\AppData\\Local\\Programs\\stack\\x86_64-windows\\ghc-7.10.3\\lib/include\\ghcversion.h" #-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-{-# LINE 12 "<command-line>" #-}
-{-# LINE 1 "templates\\GenericTemplate.hs" #-}
--- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp 
-
-{-# LINE 13 "templates\\GenericTemplate.hs" #-}
-
-
-
-
-
--- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
-#if __GLASGOW_HASKELL__ > 706
-#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool)
-#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool)
-#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool)
-#else
-#define LT(n,m) (n Happy_GHC_Exts.<# m)
-#define GTE(n,m) (n Happy_GHC_Exts.>=# m)
-#define EQ(n,m) (n Happy_GHC_Exts.==# m)
-#endif
-{-# LINE 46 "templates\\GenericTemplate.hs" #-}
-
-
-data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList
-
-
-
-
-
-{-# LINE 67 "templates\\GenericTemplate.hs" #-}
-
-{-# LINE 77 "templates\\GenericTemplate.hs" #-}
-
-{-# LINE 86 "templates\\GenericTemplate.hs" #-}
-
-infixr 9 `HappyStk`
-data HappyStk a = HappyStk a (HappyStk a)
-
------------------------------------------------------------------------------
--- starting the parse
-
-happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll
-
------------------------------------------------------------------------------
--- Accepting the parse
-
--- If the current token is 0#, it means we've just accepted a partial
--- parse (a %partial parser).  We must ignore the saved token on the top of
--- the stack in this case.
-happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =
-        happyReturn1 ans
-happyAccept j tk st sts (HappyStk ans _) = 
-        (happyTcHack j (happyTcHack st)) (happyReturn1 ans)
-
------------------------------------------------------------------------------
--- Arrays only: do the next action
-
-
-
-happyDoAction i tk st
-        = {- nothing -}
-
-
-          case action of
-                0#           -> {- nothing -}
-                                     happyFail i tk st
-                -1#          -> {- nothing -}
-                                     happyAccept i tk st
-                n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}
-
-                                                   (happyReduceArr Happy_Data_Array.! rule) i tk st
-                                                   where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))
-                n                 -> {- nothing -}
-
-
-                                     happyShift new_state i tk st
-                                     where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))
-   where off    = indexShortOffAddr happyActOffsets st
-         off_i  = (off Happy_GHC_Exts.+# i)
-         check  = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#))
-                  then EQ(indexShortOffAddr happyCheck off_i, i)
-                  else False
-         action
-          | check     = indexShortOffAddr happyTable off_i
-          | otherwise = indexShortOffAddr happyDefActions st
-
-
-indexShortOffAddr (HappyA# arr) off =
-        Happy_GHC_Exts.narrow16Int# i
-  where
-        i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)
-        high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))
-        low  = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))
-        off' = off Happy_GHC_Exts.*# 2#
-
-
-
-
-
-data HappyAddr = HappyA# Happy_GHC_Exts.Addr#
-
-
-
-
------------------------------------------------------------------------------
--- HappyState data type (not arrays)
-
-{-# LINE 170 "templates\\GenericTemplate.hs" #-}
-
------------------------------------------------------------------------------
--- Shifting a token
-
-happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =
-     let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
---     trace "shifting the error token" $
-     happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)
-
-happyShift new_state i tk st sts stk =
-     happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)
-
--- happyReduce is specialised for the common cases.
-
-happySpecReduce_0 i fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happySpecReduce_0 nt fn j tk st@((action)) sts stk
-     = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)
-
-happySpecReduce_1 i fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')
-     = let r = fn v1 in
-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
-
-happySpecReduce_2 i fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')
-     = let r = fn v1 v2 in
-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
-
-happySpecReduce_3 i fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')
-     = let r = fn v1 v2 v3 in
-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
-
-happyReduce k i fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happyReduce k nt fn j tk st sts stk
-     = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of
-         sts1@((HappyCons (st1@(action)) (_))) ->
-                let r = fn stk in  -- it doesn't hurt to always seq here...
-                happyDoSeq r (happyGoto nt j tk st1 sts1 r)
-
-happyMonadReduce k nt fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happyMonadReduce k nt fn j tk st sts stk =
-      case happyDrop k (HappyCons (st) (sts)) of
-        sts1@((HappyCons (st1@(action)) (_))) ->
-          let drop_stk = happyDropStk k stk in
-          happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))
-
-happyMonad2Reduce k nt fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happyMonad2Reduce k nt fn j tk st sts stk =
-      case happyDrop k (HappyCons (st) (sts)) of
-        sts1@((HappyCons (st1@(action)) (_))) ->
-         let drop_stk = happyDropStk k stk
-
-             off = indexShortOffAddr happyGotoOffsets st1
-             off_i = (off Happy_GHC_Exts.+# nt)
-             new_state = indexShortOffAddr happyTable off_i
-
-
-
-          in
-          happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))
-
-happyDrop 0# l = l
-happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t
-
-happyDropStk 0# l = l
-happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs
-
------------------------------------------------------------------------------
--- Moving to a new state after a reduction
-
-
-happyGoto nt j tk st = 
-   {- nothing -}
-   happyDoAction j tk new_state
-   where off = indexShortOffAddr happyGotoOffsets st
-         off_i = (off Happy_GHC_Exts.+# nt)
-         new_state = indexShortOffAddr happyTable off_i
-
-
-
-
------------------------------------------------------------------------------
--- Error recovery (0# is the error token)
-
--- parse error if we are in recovery and we fail again
-happyFail 0# tk old_st _ stk@(x `HappyStk` _) =
-     let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
---      trace "failing" $ 
-        happyError_ i tk
-
-{-  We don't need state discarding for our restricted implementation of
-    "error".  In fact, it can cause some bogus parses, so I've disabled it
-    for now --SDM
-
--- discard a state
-happyFail  0# tk old_st (HappyCons ((action)) (sts)) 
-                                                (saved_tok `HappyStk` _ `HappyStk` stk) =
---      trace ("discarding state, depth " ++ show (length stk))  $
-        happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk))
--}
-
--- Enter error recovery: generate an error token,
---                       save the old token and carry on.
-happyFail  i tk (action) sts stk =
---      trace "entering error recovery" $
-        happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)
-
--- Internal happy errors:
-
-notHappyAtAll :: a
-notHappyAtAll = error "Internal Happy error\n"
-
------------------------------------------------------------------------------
--- Hack to get the typechecker to accept our action functions
-
-
-happyTcHack :: Happy_GHC_Exts.Int# -> a -> a
-happyTcHack x y = y
-{-# INLINE happyTcHack #-}
-
-
------------------------------------------------------------------------------
--- Seq-ing.  If the --strict flag is given, then Happy emits 
---      happySeq = happyDoSeq
--- otherwise it emits
---      happySeq = happyDontSeq
-
-happyDoSeq, happyDontSeq :: a -> b -> b
-happyDoSeq   a b = a `seq` b
-happyDontSeq a b = b
-
------------------------------------------------------------------------------
--- Don't inline any functions from the template.  GHC has a nasty habit
--- of deciding to inline happyGoto everywhere, which increases the size of
--- the generated parser quite a bit.
-
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE PatternGuards #-}
+{-# LANGUAGE NoStrictData #-}
+{-# LANGUAGE UnboxedTuples #-}
+{-# LANGUAGE PartialTypeSignatures #-}
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
+module Language.Clafer.Front.ParClafer where
+import Language.Clafer.Front.AbsClafer
+import Language.Clafer.Front.LexClafer
+import Language.Clafer.Front.ErrM
+import qualified Control.Monad as Happy_Prelude
+import qualified Data.Bool as Happy_Prelude
+import qualified Data.Function as Happy_Prelude
+import qualified Data.Int as Happy_Prelude
+import qualified Data.List as Happy_Prelude
+import qualified Data.Maybe as Happy_Prelude
+import qualified Data.String as Happy_Prelude
+import qualified Data.Tuple as Happy_Prelude
+import qualified GHC.Err as Happy_Prelude
+import qualified GHC.Num as Happy_Prelude
+import qualified Text.Show as Happy_Prelude
+import qualified Data.Array as Happy_Data_Array
+import qualified Data.Bits as Bits
+import qualified GHC.Exts as Happy_GHC_Exts
+import Control.Applicative(Applicative(..))
+import Control.Monad (ap)
+
+-- parser produced by Happy Version 2.1.7
+
+newtype HappyAbsSyn  = HappyAbsSyn HappyAny
+#if __GLASGOW_HASKELL__ >= 607
+type HappyAny = Happy_GHC_Exts.Any
+#else
+type HappyAny = forall a . a
+#endif
+newtype HappyWrap9 = HappyWrap9 (PosInteger)
+happyIn9 :: (PosInteger) -> (HappyAbsSyn )
+happyIn9 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap9 x)
+{-# INLINE happyIn9 #-}
+happyOut9 :: (HappyAbsSyn ) -> HappyWrap9
+happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut9 #-}
+newtype HappyWrap10 = HappyWrap10 (PosDouble)
+happyIn10 :: (PosDouble) -> (HappyAbsSyn )
+happyIn10 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap10 x)
+{-# INLINE happyIn10 #-}
+happyOut10 :: (HappyAbsSyn ) -> HappyWrap10
+happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut10 #-}
+newtype HappyWrap11 = HappyWrap11 (PosReal)
+happyIn11 :: (PosReal) -> (HappyAbsSyn )
+happyIn11 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap11 x)
+{-# INLINE happyIn11 #-}
+happyOut11 :: (HappyAbsSyn ) -> HappyWrap11
+happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut11 #-}
+newtype HappyWrap12 = HappyWrap12 (PosString)
+happyIn12 :: (PosString) -> (HappyAbsSyn )
+happyIn12 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap12 x)
+{-# INLINE happyIn12 #-}
+happyOut12 :: (HappyAbsSyn ) -> HappyWrap12
+happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut12 #-}
+newtype HappyWrap13 = HappyWrap13 (PosIdent)
+happyIn13 :: (PosIdent) -> (HappyAbsSyn )
+happyIn13 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap13 x)
+{-# INLINE happyIn13 #-}
+happyOut13 :: (HappyAbsSyn ) -> HappyWrap13
+happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut13 #-}
+newtype HappyWrap14 = HappyWrap14 (PosLineComment)
+happyIn14 :: (PosLineComment) -> (HappyAbsSyn )
+happyIn14 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap14 x)
+{-# INLINE happyIn14 #-}
+happyOut14 :: (HappyAbsSyn ) -> HappyWrap14
+happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut14 #-}
+newtype HappyWrap15 = HappyWrap15 (PosBlockComment)
+happyIn15 :: (PosBlockComment) -> (HappyAbsSyn )
+happyIn15 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap15 x)
+{-# INLINE happyIn15 #-}
+happyOut15 :: (HappyAbsSyn ) -> HappyWrap15
+happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut15 #-}
+newtype HappyWrap16 = HappyWrap16 (PosAlloy)
+happyIn16 :: (PosAlloy) -> (HappyAbsSyn )
+happyIn16 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap16 x)
+{-# INLINE happyIn16 #-}
+happyOut16 :: (HappyAbsSyn ) -> HappyWrap16
+happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut16 #-}
+newtype HappyWrap17 = HappyWrap17 (PosChoco)
+happyIn17 :: (PosChoco) -> (HappyAbsSyn )
+happyIn17 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap17 x)
+{-# INLINE happyIn17 #-}
+happyOut17 :: (HappyAbsSyn ) -> HappyWrap17
+happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut17 #-}
+newtype HappyWrap18 = HappyWrap18 (Module)
+happyIn18 :: (Module) -> (HappyAbsSyn )
+happyIn18 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap18 x)
+{-# INLINE happyIn18 #-}
+happyOut18 :: (HappyAbsSyn ) -> HappyWrap18
+happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut18 #-}
+newtype HappyWrap19 = HappyWrap19 (Declaration)
+happyIn19 :: (Declaration) -> (HappyAbsSyn )
+happyIn19 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap19 x)
+{-# INLINE happyIn19 #-}
+happyOut19 :: (HappyAbsSyn ) -> HappyWrap19
+happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut19 #-}
+newtype HappyWrap20 = HappyWrap20 (Clafer)
+happyIn20 :: (Clafer) -> (HappyAbsSyn )
+happyIn20 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap20 x)
+{-# INLINE happyIn20 #-}
+happyOut20 :: (HappyAbsSyn ) -> HappyWrap20
+happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut20 #-}
+newtype HappyWrap21 = HappyWrap21 (Constraint)
+happyIn21 :: (Constraint) -> (HappyAbsSyn )
+happyIn21 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap21 x)
+{-# INLINE happyIn21 #-}
+happyOut21 :: (HappyAbsSyn ) -> HappyWrap21
+happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut21 #-}
+newtype HappyWrap22 = HappyWrap22 (Assertion)
+happyIn22 :: (Assertion) -> (HappyAbsSyn )
+happyIn22 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap22 x)
+{-# INLINE happyIn22 #-}
+happyOut22 :: (HappyAbsSyn ) -> HappyWrap22
+happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut22 #-}
+newtype HappyWrap23 = HappyWrap23 (Goal)
+happyIn23 :: (Goal) -> (HappyAbsSyn )
+happyIn23 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap23 x)
+{-# INLINE happyIn23 #-}
+happyOut23 :: (HappyAbsSyn ) -> HappyWrap23
+happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut23 #-}
+newtype HappyWrap24 = HappyWrap24 (TempModifier)
+happyIn24 :: (TempModifier) -> (HappyAbsSyn )
+happyIn24 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap24 x)
+{-# INLINE happyIn24 #-}
+happyOut24 :: (HappyAbsSyn ) -> HappyWrap24
+happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut24 #-}
+newtype HappyWrap25 = HappyWrap25 (Transition)
+happyIn25 :: (Transition) -> (HappyAbsSyn )
+happyIn25 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap25 x)
+{-# INLINE happyIn25 #-}
+happyOut25 :: (HappyAbsSyn ) -> HappyWrap25
+happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut25 #-}
+newtype HappyWrap26 = HappyWrap26 (Abstract)
+happyIn26 :: (Abstract) -> (HappyAbsSyn )
+happyIn26 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap26 x)
+{-# INLINE happyIn26 #-}
+happyOut26 :: (HappyAbsSyn ) -> HappyWrap26
+happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut26 #-}
+newtype HappyWrap27 = HappyWrap27 (Elements)
+happyIn27 :: (Elements) -> (HappyAbsSyn )
+happyIn27 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap27 x)
+{-# INLINE happyIn27 #-}
+happyOut27 :: (HappyAbsSyn ) -> HappyWrap27
+happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut27 #-}
+newtype HappyWrap28 = HappyWrap28 (Element)
+happyIn28 :: (Element) -> (HappyAbsSyn )
+happyIn28 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap28 x)
+{-# INLINE happyIn28 #-}
+happyOut28 :: (HappyAbsSyn ) -> HappyWrap28
+happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut28 #-}
+newtype HappyWrap29 = HappyWrap29 (Super)
+happyIn29 :: (Super) -> (HappyAbsSyn )
+happyIn29 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap29 x)
+{-# INLINE happyIn29 #-}
+happyOut29 :: (HappyAbsSyn ) -> HappyWrap29
+happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut29 #-}
+newtype HappyWrap30 = HappyWrap30 (Reference)
+happyIn30 :: (Reference) -> (HappyAbsSyn )
+happyIn30 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap30 x)
+{-# INLINE happyIn30 #-}
+happyOut30 :: (HappyAbsSyn ) -> HappyWrap30
+happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut30 #-}
+newtype HappyWrap31 = HappyWrap31 (Init)
+happyIn31 :: (Init) -> (HappyAbsSyn )
+happyIn31 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap31 x)
+{-# INLINE happyIn31 #-}
+happyOut31 :: (HappyAbsSyn ) -> HappyWrap31
+happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut31 #-}
+newtype HappyWrap32 = HappyWrap32 (InitHow)
+happyIn32 :: (InitHow) -> (HappyAbsSyn )
+happyIn32 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap32 x)
+{-# INLINE happyIn32 #-}
+happyOut32 :: (HappyAbsSyn ) -> HappyWrap32
+happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut32 #-}
+newtype HappyWrap33 = HappyWrap33 (GCard)
+happyIn33 :: (GCard) -> (HappyAbsSyn )
+happyIn33 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap33 x)
+{-# INLINE happyIn33 #-}
+happyOut33 :: (HappyAbsSyn ) -> HappyWrap33
+happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut33 #-}
+newtype HappyWrap34 = HappyWrap34 (Card)
+happyIn34 :: (Card) -> (HappyAbsSyn )
+happyIn34 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap34 x)
+{-# INLINE happyIn34 #-}
+happyOut34 :: (HappyAbsSyn ) -> HappyWrap34
+happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut34 #-}
+newtype HappyWrap35 = HappyWrap35 (NCard)
+happyIn35 :: (NCard) -> (HappyAbsSyn )
+happyIn35 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap35 x)
+{-# INLINE happyIn35 #-}
+happyOut35 :: (HappyAbsSyn ) -> HappyWrap35
+happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut35 #-}
+newtype HappyWrap36 = HappyWrap36 (ExInteger)
+happyIn36 :: (ExInteger) -> (HappyAbsSyn )
+happyIn36 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap36 x)
+{-# INLINE happyIn36 #-}
+happyOut36 :: (HappyAbsSyn ) -> HappyWrap36
+happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut36 #-}
+newtype HappyWrap37 = HappyWrap37 (Name)
+happyIn37 :: (Name) -> (HappyAbsSyn )
+happyIn37 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap37 x)
+{-# INLINE happyIn37 #-}
+happyOut37 :: (HappyAbsSyn ) -> HappyWrap37
+happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut37 #-}
+newtype HappyWrap38 = HappyWrap38 (Exp)
+happyIn38 :: (Exp) -> (HappyAbsSyn )
+happyIn38 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap38 x)
+{-# INLINE happyIn38 #-}
+happyOut38 :: (HappyAbsSyn ) -> HappyWrap38
+happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut38 #-}
+newtype HappyWrap39 = HappyWrap39 (Exp)
+happyIn39 :: (Exp) -> (HappyAbsSyn )
+happyIn39 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap39 x)
+{-# INLINE happyIn39 #-}
+happyOut39 :: (HappyAbsSyn ) -> HappyWrap39
+happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut39 #-}
+newtype HappyWrap40 = HappyWrap40 (Exp)
+happyIn40 :: (Exp) -> (HappyAbsSyn )
+happyIn40 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap40 x)
+{-# INLINE happyIn40 #-}
+happyOut40 :: (HappyAbsSyn ) -> HappyWrap40
+happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut40 #-}
+newtype HappyWrap41 = HappyWrap41 (Exp)
+happyIn41 :: (Exp) -> (HappyAbsSyn )
+happyIn41 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap41 x)
+{-# INLINE happyIn41 #-}
+happyOut41 :: (HappyAbsSyn ) -> HappyWrap41
+happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut41 #-}
+newtype HappyWrap42 = HappyWrap42 (Exp)
+happyIn42 :: (Exp) -> (HappyAbsSyn )
+happyIn42 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap42 x)
+{-# INLINE happyIn42 #-}
+happyOut42 :: (HappyAbsSyn ) -> HappyWrap42
+happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut42 #-}
+newtype HappyWrap43 = HappyWrap43 (Exp)
+happyIn43 :: (Exp) -> (HappyAbsSyn )
+happyIn43 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap43 x)
+{-# INLINE happyIn43 #-}
+happyOut43 :: (HappyAbsSyn ) -> HappyWrap43
+happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut43 #-}
+newtype HappyWrap44 = HappyWrap44 (Exp)
+happyIn44 :: (Exp) -> (HappyAbsSyn )
+happyIn44 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap44 x)
+{-# INLINE happyIn44 #-}
+happyOut44 :: (HappyAbsSyn ) -> HappyWrap44
+happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut44 #-}
+newtype HappyWrap45 = HappyWrap45 (Exp)
+happyIn45 :: (Exp) -> (HappyAbsSyn )
+happyIn45 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap45 x)
+{-# INLINE happyIn45 #-}
+happyOut45 :: (HappyAbsSyn ) -> HappyWrap45
+happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut45 #-}
+newtype HappyWrap46 = HappyWrap46 (Exp)
+happyIn46 :: (Exp) -> (HappyAbsSyn )
+happyIn46 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap46 x)
+{-# INLINE happyIn46 #-}
+happyOut46 :: (HappyAbsSyn ) -> HappyWrap46
+happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut46 #-}
+newtype HappyWrap47 = HappyWrap47 (Exp)
+happyIn47 :: (Exp) -> (HappyAbsSyn )
+happyIn47 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap47 x)
+{-# INLINE happyIn47 #-}
+happyOut47 :: (HappyAbsSyn ) -> HappyWrap47
+happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut47 #-}
+newtype HappyWrap48 = HappyWrap48 (Exp)
+happyIn48 :: (Exp) -> (HappyAbsSyn )
+happyIn48 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap48 x)
+{-# INLINE happyIn48 #-}
+happyOut48 :: (HappyAbsSyn ) -> HappyWrap48
+happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut48 #-}
+newtype HappyWrap49 = HappyWrap49 (Exp)
+happyIn49 :: (Exp) -> (HappyAbsSyn )
+happyIn49 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap49 x)
+{-# INLINE happyIn49 #-}
+happyOut49 :: (HappyAbsSyn ) -> HappyWrap49
+happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut49 #-}
+newtype HappyWrap50 = HappyWrap50 (Exp)
+happyIn50 :: (Exp) -> (HappyAbsSyn )
+happyIn50 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap50 x)
+{-# INLINE happyIn50 #-}
+happyOut50 :: (HappyAbsSyn ) -> HappyWrap50
+happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut50 #-}
+newtype HappyWrap51 = HappyWrap51 (Exp)
+happyIn51 :: (Exp) -> (HappyAbsSyn )
+happyIn51 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap51 x)
+{-# INLINE happyIn51 #-}
+happyOut51 :: (HappyAbsSyn ) -> HappyWrap51
+happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut51 #-}
+newtype HappyWrap52 = HappyWrap52 (Exp)
+happyIn52 :: (Exp) -> (HappyAbsSyn )
+happyIn52 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap52 x)
+{-# INLINE happyIn52 #-}
+happyOut52 :: (HappyAbsSyn ) -> HappyWrap52
+happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut52 #-}
+newtype HappyWrap53 = HappyWrap53 (Exp)
+happyIn53 :: (Exp) -> (HappyAbsSyn )
+happyIn53 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap53 x)
+{-# INLINE happyIn53 #-}
+happyOut53 :: (HappyAbsSyn ) -> HappyWrap53
+happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut53 #-}
+newtype HappyWrap54 = HappyWrap54 (Exp)
+happyIn54 :: (Exp) -> (HappyAbsSyn )
+happyIn54 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap54 x)
+{-# INLINE happyIn54 #-}
+happyOut54 :: (HappyAbsSyn ) -> HappyWrap54
+happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut54 #-}
+newtype HappyWrap55 = HappyWrap55 (Exp)
+happyIn55 :: (Exp) -> (HappyAbsSyn )
+happyIn55 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap55 x)
+{-# INLINE happyIn55 #-}
+happyOut55 :: (HappyAbsSyn ) -> HappyWrap55
+happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut55 #-}
+newtype HappyWrap56 = HappyWrap56 (Exp)
+happyIn56 :: (Exp) -> (HappyAbsSyn )
+happyIn56 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap56 x)
+{-# INLINE happyIn56 #-}
+happyOut56 :: (HappyAbsSyn ) -> HappyWrap56
+happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut56 #-}
+newtype HappyWrap57 = HappyWrap57 (Exp)
+happyIn57 :: (Exp) -> (HappyAbsSyn )
+happyIn57 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap57 x)
+{-# INLINE happyIn57 #-}
+happyOut57 :: (HappyAbsSyn ) -> HappyWrap57
+happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut57 #-}
+newtype HappyWrap58 = HappyWrap58 (Exp)
+happyIn58 :: (Exp) -> (HappyAbsSyn )
+happyIn58 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap58 x)
+{-# INLINE happyIn58 #-}
+happyOut58 :: (HappyAbsSyn ) -> HappyWrap58
+happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut58 #-}
+newtype HappyWrap59 = HappyWrap59 (Exp)
+happyIn59 :: (Exp) -> (HappyAbsSyn )
+happyIn59 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap59 x)
+{-# INLINE happyIn59 #-}
+happyOut59 :: (HappyAbsSyn ) -> HappyWrap59
+happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut59 #-}
+newtype HappyWrap60 = HappyWrap60 (Exp)
+happyIn60 :: (Exp) -> (HappyAbsSyn )
+happyIn60 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap60 x)
+{-# INLINE happyIn60 #-}
+happyOut60 :: (HappyAbsSyn ) -> HappyWrap60
+happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut60 #-}
+newtype HappyWrap61 = HappyWrap61 (Exp)
+happyIn61 :: (Exp) -> (HappyAbsSyn )
+happyIn61 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap61 x)
+{-# INLINE happyIn61 #-}
+happyOut61 :: (HappyAbsSyn ) -> HappyWrap61
+happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut61 #-}
+newtype HappyWrap62 = HappyWrap62 (Exp)
+happyIn62 :: (Exp) -> (HappyAbsSyn )
+happyIn62 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap62 x)
+{-# INLINE happyIn62 #-}
+happyOut62 :: (HappyAbsSyn ) -> HappyWrap62
+happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut62 #-}
+newtype HappyWrap63 = HappyWrap63 (TransGuard)
+happyIn63 :: (TransGuard) -> (HappyAbsSyn )
+happyIn63 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap63 x)
+{-# INLINE happyIn63 #-}
+happyOut63 :: (HappyAbsSyn ) -> HappyWrap63
+happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut63 #-}
+newtype HappyWrap64 = HappyWrap64 (TransArrow)
+happyIn64 :: (TransArrow) -> (HappyAbsSyn )
+happyIn64 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap64 x)
+{-# INLINE happyIn64 #-}
+happyOut64 :: (HappyAbsSyn ) -> HappyWrap64
+happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut64 #-}
+newtype HappyWrap65 = HappyWrap65 (PatternScope)
+happyIn65 :: (PatternScope) -> (HappyAbsSyn )
+happyIn65 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap65 x)
+{-# INLINE happyIn65 #-}
+happyOut65 :: (HappyAbsSyn ) -> HappyWrap65
+happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut65 #-}
+newtype HappyWrap66 = HappyWrap66 (Decl)
+happyIn66 :: (Decl) -> (HappyAbsSyn )
+happyIn66 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap66 x)
+{-# INLINE happyIn66 #-}
+happyOut66 :: (HappyAbsSyn ) -> HappyWrap66
+happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut66 #-}
+newtype HappyWrap67 = HappyWrap67 (VarBinding)
+happyIn67 :: (VarBinding) -> (HappyAbsSyn )
+happyIn67 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap67 x)
+{-# INLINE happyIn67 #-}
+happyOut67 :: (HappyAbsSyn ) -> HappyWrap67
+happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut67 #-}
+newtype HappyWrap68 = HappyWrap68 (Quant)
+happyIn68 :: (Quant) -> (HappyAbsSyn )
+happyIn68 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap68 x)
+{-# INLINE happyIn68 #-}
+happyOut68 :: (HappyAbsSyn ) -> HappyWrap68
+happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut68 #-}
+newtype HappyWrap69 = HappyWrap69 (EnumId)
+happyIn69 :: (EnumId) -> (HappyAbsSyn )
+happyIn69 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap69 x)
+{-# INLINE happyIn69 #-}
+happyOut69 :: (HappyAbsSyn ) -> HappyWrap69
+happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut69 #-}
+newtype HappyWrap70 = HappyWrap70 (ModId)
+happyIn70 :: (ModId) -> (HappyAbsSyn )
+happyIn70 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap70 x)
+{-# INLINE happyIn70 #-}
+happyOut70 :: (HappyAbsSyn ) -> HappyWrap70
+happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut70 #-}
+newtype HappyWrap71 = HappyWrap71 (LocId)
+happyIn71 :: (LocId) -> (HappyAbsSyn )
+happyIn71 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap71 x)
+{-# INLINE happyIn71 #-}
+happyOut71 :: (HappyAbsSyn ) -> HappyWrap71
+happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut71 #-}
+newtype HappyWrap72 = HappyWrap72 ([Declaration])
+happyIn72 :: ([Declaration]) -> (HappyAbsSyn )
+happyIn72 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap72 x)
+{-# INLINE happyIn72 #-}
+happyOut72 :: (HappyAbsSyn ) -> HappyWrap72
+happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut72 #-}
+newtype HappyWrap73 = HappyWrap73 ([EnumId])
+happyIn73 :: ([EnumId]) -> (HappyAbsSyn )
+happyIn73 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap73 x)
+{-# INLINE happyIn73 #-}
+happyOut73 :: (HappyAbsSyn ) -> HappyWrap73
+happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut73 #-}
+newtype HappyWrap74 = HappyWrap74 ([Element])
+happyIn74 :: ([Element]) -> (HappyAbsSyn )
+happyIn74 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap74 x)
+{-# INLINE happyIn74 #-}
+happyOut74 :: (HappyAbsSyn ) -> HappyWrap74
+happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut74 #-}
+newtype HappyWrap75 = HappyWrap75 ([Exp])
+happyIn75 :: ([Exp]) -> (HappyAbsSyn )
+happyIn75 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap75 x)
+{-# INLINE happyIn75 #-}
+happyOut75 :: (HappyAbsSyn ) -> HappyWrap75
+happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut75 #-}
+newtype HappyWrap76 = HappyWrap76 ([TempModifier])
+happyIn76 :: ([TempModifier]) -> (HappyAbsSyn )
+happyIn76 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap76 x)
+{-# INLINE happyIn76 #-}
+happyOut76 :: (HappyAbsSyn ) -> HappyWrap76
+happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut76 #-}
+newtype HappyWrap77 = HappyWrap77 ([LocId])
+happyIn77 :: ([LocId]) -> (HappyAbsSyn )
+happyIn77 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap77 x)
+{-# INLINE happyIn77 #-}
+happyOut77 :: (HappyAbsSyn ) -> HappyWrap77
+happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut77 #-}
+newtype HappyWrap78 = HappyWrap78 ([ModId])
+happyIn78 :: ([ModId]) -> (HappyAbsSyn )
+happyIn78 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap78 x)
+{-# INLINE happyIn78 #-}
+happyOut78 :: (HappyAbsSyn ) -> HappyWrap78
+happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut78 #-}
+newtype HappyWrap79 = HappyWrap79 (Exp)
+happyIn79 :: (Exp) -> (HappyAbsSyn )
+happyIn79 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap79 x)
+{-# INLINE happyIn79 #-}
+happyOut79 :: (HappyAbsSyn ) -> HappyWrap79
+happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut79 #-}
+newtype HappyWrap80 = HappyWrap80 (Exp)
+happyIn80 :: (Exp) -> (HappyAbsSyn )
+happyIn80 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap80 x)
+{-# INLINE happyIn80 #-}
+happyOut80 :: (HappyAbsSyn ) -> HappyWrap80
+happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut80 #-}
+newtype HappyWrap81 = HappyWrap81 (Exp)
+happyIn81 :: (Exp) -> (HappyAbsSyn )
+happyIn81 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap81 x)
+{-# INLINE happyIn81 #-}
+happyOut81 :: (HappyAbsSyn ) -> HappyWrap81
+happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut81 #-}
+happyInTok :: (Token) -> (HappyAbsSyn )
+happyInTok x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyInTok #-}
+happyOutTok :: (HappyAbsSyn ) -> (Token)
+happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOutTok #-}
+
+
+{-# NOINLINE happyTokenStrings #-}
+happyTokenStrings = ["'!'","'!='","'#'","'%'","'&'","'&&'","'('","')'","'*'","'**'","'+'","'++'","','","'-'","'--'","'-->'","'-->>'","'->'","'->>'","'-['","'.'","'..'","'/'","':'","':='","':>'","';'","L_sep","'<'","'<:'","'<<'","'<='","'<=>'","'='","'=>'","'>'","'>='","'>>'","'?'","'F'","'G'","'U'","'W'","'X'","'['","'\\\\'","']'","']->'","']->>'","'`'","'abstract'","'after'","'all'","'always'","'and'","'assert'","'before'","'between'","'disj'","'else'","'enum'","'eventually'","'final'","'finally'","'finalref'","'finaltarget'","'follow'","'globally'","'if'","'in'","'initial'","'initially'","'let'","'lonce'","'lone'","'max'","'maximize'","'min'","'minimize'","'must'","'mux'","'never'","'next'","'no'","'not'","'one'","'opt'","'or'","'precede'","'product'","'some'","'sometime'","'sum'","'then'","'until'","'weakuntil'","'xor'","'{'","'|'","'||'","'}'","L_PosInteger","L_PosDouble","L_PosReal","L_PosString","L_PosIdent","L_PosLineComment","L_PosBlockComment","L_PosAlloy","L_PosChoco","%eof"]
+
+happyActOffsets :: HappyAddr
+happyActOffsets = HappyA# "\x00\x00\x00\x00\xdd\xff\xff\xff\xed\xff\xff\xff\xf4\xff\xff\xff\x5a\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x9a\x01\x00\x00\x19\x00\x00\x00\x69\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x00\x00\x00\xe9\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x30\x00\x00\x00\x1e\x02\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x6f\x00\x00\x00\xa7\x00\x00\x00\xdf\x00\x00\x00\x3c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x01\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x8d\x00\x00\x00\x4e\x00\x00\x00\x5d\x00\x00\x00\xc8\x00\x00\x00\xe1\xff\xff\xff\xec\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x01\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\xc0\x00\x00\x00\x62\x00\x00\x00\xcc\x00\x00\x00\xd5\x00\x00\x00\x97\x00\x00\x00\x00\x00\x00\x00\xf1\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x01\x00\x00\xf7\x00\x00\x00\x74\x01\x00\x00\xf7\x00\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\x00\x00\x00\x00\xd1\xff\xff\xff\xac\x01\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\x74\x01\x00\x00\xac\x01\x00\x00\x80\x00\x00\x00\xac\x01\x00\x00\x00\x00\x00\x00\x28\x02\x00\x00\x28\x02\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x00\x00\x00\x00\x00\x00\x00\xac\x01\x00\x00\xf7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x00\x00\x00\xf8\xff\xff\xff\xea\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\xfb\x00\x00\x00\xfb\xff\xff\xff\xf9\x00\x00\x00\x45\x01\x00\x00\x28\x02\x00\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x45\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x01\x00\x00\x00\x00\x00\x00\xda\x00\x00\x00\x00\x01\x00\x00\x0e\x01\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x0f\x01\x00\x00\x00\x00\x00\x00\x45\x01\x00\x00\xd4\x00\x00\x00\x1d\x01\x00\x00\x26\x01\x00\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x01\x00\x00\x3a\x01\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\xe3\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\xe8\x00\x00\x00\xf7\x00\x00\x00\xf7\x00\x00\x00\xf7\x00\x00\x00\xf7\x00\x00\x00\xf7\x00\x00\x00\xf7\x00\x00\x00\xf7\x00\x00\x00\xf7\x00\x00\x00\xbe\x01\x00\x00\xbe\x01\x00\x00\xbe\x01\x00\x00\xbe\x01\x00\x00\xbe\x01\x00\x00\x01\x02\x00\x00\x01\x02\x00\x00\x01\x02\x00\x00\x01\x02\x00\x00\x01\x02\x00\x00\x01\x02\x00\x00\x01\x02\x00\x00\xfe\x00\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\xcb\xff\xff\xff\x74\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\xac\x01\x00\x00\xac\x01\x00\x00\x30\x01\x00\x00\xf2\x00\x00\x00\x01\x01\x00\x00\x4f\x01\x00\x00\x05\x00\x00\x00\xf7\xff\xff\xff\xf7\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x01\x00\x00\x96\x00\x00\x00\x58\x01\x00\x00\x58\x01\x00\x00\x5f\x01\x00\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x01\x00\x00\x74\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x01\x00\x00\xf7\x00\x00\x00\x05\x01\x00\x00\x74\x01\x00\x00\x00\x00\x00\x00\xde\x01\x00\x00\xde\x01\x00\x00\xde\x01\x00\x00\x74\x01\x00\x00\x01\x02\x00\x00\x74\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\xf7\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\xff\xff\xff\x06\x01\x00\x00\x97\x00\x00\x00\xf8\xff\xff\xff\xf7\x00\x00\x00\xf7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x01\x00\x00\x3f\x01\x00\x00\x00\x00\x00\x00\x19\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x01\x00\x00\x74\x01\x00\x00\x00\x00\x00\x00\x74\x01\x00\x00\x00\x00\x00\x00\x45\x01\x00\x00\x45\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x01\x00\x00\xde\x01\x00\x00\x74\x01\x00\x00\xc5\x00\x00\x00\xc5\x00\x00\x00\x77\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x01\x00\x00\x74\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x01\x00\x00\x74\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
+
+happyGotoOffsets :: HappyAddr
+happyGotoOffsets = HappyA# "\x11\x00\x00\x00\x27\x00\x00\x00\x7e\x01\x00\x00\x7f\x01\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x01\x00\x00\x00\x00\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x91\x01\x00\x00\x55\x01\x00\x00\x78\x02\x00\x00\x54\x01\x00\x00\x59\x01\x00\x00\x5a\x01\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x78\x02\x00\x00\x78\x02\x00\x00\x78\x02\x00\x00\x78\x02\x00\x00\x78\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x09\x00\x00\x3f\x0d\x00\x00\xae\x02\x00\x00\x46\x0d\x00\x00\x9e\x08\x00\x00\xc0\x08\x00\x00\xf6\x08\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x74\x05\x00\x00\x18\x09\x00\x00\xaa\x05\x00\x00\x4e\x09\x00\x00\xc4\x03\x00\x00\xe0\x05\x00\x00\xe1\x00\x00\x00\x16\x06\x00\x00\x00\x00\x00\x00\xe3\x0c\x00\x00\x00\x0d\x00\x00\x4c\x06\x00\x00\x70\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x0d\x00\x00\x00\x00\x00\x00\x82\x06\x00\x00\x86\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x01\x00\x00\x00\x00\x00\x00\x97\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x98\x01\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x75\x01\x00\x00\x22\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x12\x00\x00\x00\x39\x0e\x00\x00\xfa\x0d\x00\x00\x25\x0e\x00\x00\xe7\x0d\x00\x00\x11\x0e\x00\x00\x93\x0d\x00\x00\xb0\x0d\x00\x00\x82\x0c\x00\x00\xa4\x0c\x00\x00\xc1\x0c\x00\x00\x42\x0c\x00\x00\x65\x0c\x00\x00\x06\x0b\x00\x00\x23\x0b\x00\x00\x45\x0b\x00\x00\x62\x0b\x00\x00\x84\x0b\x00\x00\xa1\x0b\x00\x00\xc3\x0b\x00\x00\x00\x00\x00\x00\xa6\x09\x00\x00\xc8\x09\x00\x00\x32\x08\x00\x00\x68\x08\x00\x00\xfc\x07\x00\x00\xc6\x07\x00\x00\x90\x07\x00\x00\x5a\x07\x00\x00\x24\x07\x00\x00\x00\x00\x00\x00\xe4\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x06\x00\x00\xee\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x0d\x00\x00\x83\x00\x00\x00\x30\x04\x00\x00\x00\x00\x00\x00\x20\x0a\x00\x00\x56\x0a\x00\x00\x78\x0a\x00\x00\x66\x04\x00\x00\x02\x0c\x00\x00\x9c\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x01\x00\x00\x30\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x01\x00\x00\xb6\x02\x00\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x37\x01\x00\x00\xd3\x0d\x00\x00\xda\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x04\x00\x00\x00\x00\x00\x00\x08\x05\x00\x00\x00\x00\x00\x00\x84\x01\x00\x00\x8c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x0a\x00\x00\xd0\x0a\x00\x00\x3e\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\xff\xff\xff\x58\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x01\x00\x00\x8e\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
+
+happyDefActions :: HappyAddr
+happyDefActions = HappyA# "\x52\xff\xff\xff\xe1\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\xff\xff\xff\x00\x00\x00\x00\x48\xff\xff\xff\xe0\xff\xff\xff\x00\x00\x00\x00\xe1\xff\xff\xff\x51\xff\xff\xff\xdd\xff\xff\xff\xdb\xff\xff\xff\xd9\xff\xff\xff\xda\xff\xff\xff\xef\xff\xff\xff\x50\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xcf\xff\xff\xff\x00\x00\x00\x00\x4a\xff\xff\xff\x4a\xff\xff\xff\x4a\xff\xff\xff\x4a\xff\xff\xff\x4a\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\xff\xff\xff\x6a\xff\xff\xff\x69\xff\xff\xff\x68\xff\xff\xff\x54\xff\xff\xff\x6c\xff\xff\xff\x49\xff\xff\xff\xbe\xff\xff\xff\xb7\xff\xff\xff\xae\xff\xff\xff\xac\xff\xff\xff\xaa\xff\xff\xff\xa8\xff\xff\xff\xa6\xff\xff\xff\xa4\xff\xff\xff\xa1\xff\xff\xff\x9e\xff\xff\xff\x97\xff\xff\xff\x40\xff\xff\xff\x8c\xff\xff\xff\x8a\xff\xff\xff\x87\xff\xff\xff\x83\xff\xff\xff\x80\xff\xff\xff\x7b\xff\xff\xff\x79\xff\xff\xff\x77\xff\xff\xff\x74\xff\xff\xff\x72\xff\xff\xff\x70\xff\xff\xff\x6d\xff\xff\xff\x00\x00\x00\x00\x44\xff\xff\xff\xc0\xff\xff\xff\x95\xff\xff\xff\x42\xff\xff\xff\x41\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\xff\xff\xff\x59\xff\xff\xff\x57\xff\xff\xff\x00\x00\x00\x00\x56\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf9\xff\xff\xff\xf8\xff\xff\xff\xf7\xff\xff\xff\xf6\xff\xff\xff\x00\x00\x00\x00\x47\xff\xff\xff\x00\x00\x00\x00\xca\xff\xff\xff\xe6\xff\xff\xff\xe5\xff\xff\xff\xe4\xff\xff\xff\xe7\xff\xff\xff\xcc\xff\xff\xff\xcb\xff\xff\xff\xcd\xff\xff\xff\xce\xff\xff\xff\x00\x00\x00\x00\xc9\xff\xff\xff\xc5\xff\xff\xff\xdf\xff\xff\xff\xc4\xff\xff\xff\xc6\xff\xff\xff\xc7\xff\xff\xff\xc8\xff\xff\xff\x00\x00\x00\x00\xd8\xff\xff\xff\x00\x00\x00\x00\x7f\xff\xff\xff\x5d\xff\xff\xff\x00\x00\x00\x00\x7e\xff\xff\xff\x98\xff\xff\xff\x5d\xff\xff\xff\x81\xff\xff\xff\x82\xff\xff\xff\x5d\xff\xff\xff\x53\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xff\xff\xff\x00\x00\x00\x00\x9a\xff\xff\xff\xaf\xff\xff\xff\x9c\xff\xff\xff\x5d\xff\xff\xff\x00\x00\x00\x00\x46\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x99\xff\xff\xff\x9b\xff\xff\xff\x9d\xff\xff\xff\x7c\xff\xff\xff\x00\x00\x00\x00\x7d\xff\xff\xff\x96\xff\xff\xff\x00\x00\x00\x00\x54\xff\xff\xff\x8b\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\xff\xff\xff\x65\xff\xff\xff\x00\x00\x00\x00\xec\xff\xff\xff\xea\xff\xff\xff\xe8\xff\xff\xff\xeb\xff\xff\xff\xe9\xff\xff\xff\x66\xff\xff\xff\x00\x00\x00\x00\xbf\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xad\xff\xff\xff\xab\xff\xff\xff\xa9\xff\xff\xff\xa7\xff\xff\xff\xa5\xff\xff\xff\xa2\xff\xff\xff\xa3\xff\xff\xff\x9f\xff\xff\xff\xa0\xff\xff\xff\x00\x00\x00\x00\x8e\xff\xff\xff\x90\xff\xff\xff\x93\xff\xff\xff\x92\xff\xff\xff\x91\xff\xff\xff\x94\xff\xff\xff\x8f\xff\xff\xff\x88\xff\xff\xff\x89\xff\xff\xff\x85\xff\xff\xff\x86\xff\xff\xff\x84\xff\xff\xff\x7a\xff\xff\xff\x78\xff\xff\xff\x75\xff\xff\xff\x76\xff\xff\xff\x73\xff\xff\xff\x71\xff\xff\xff\x6e\xff\xff\xff\x6f\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x43\xff\xff\xff\x67\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\xff\xff\xff\xb6\xff\xff\xff\xb5\xff\xff\xff\xc1\xff\xff\xff\xc3\xff\xff\xff\xc2\xff\xff\xff\xd6\xff\xff\xff\x00\x00\x00\x00\x55\xff\xff\xff\x4f\xff\xff\xff\xf0\xff\xff\xff\xdc\xff\xff\xff\x4d\xff\xff\xff\xe1\xff\xff\xff\x00\x00\x00\x00\xd7\xff\xff\xff\xc9\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xb8\xff\xff\xff\x5b\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x61\xff\xff\xff\x60\xff\xff\xff\xbc\xff\xff\xff\x45\xff\xff\xff\x5c\xff\xff\xff\x00\x00\x00\x00\xba\xff\xff\xff\x00\x00\x00\x00\x8d\xff\xff\xff\x5d\xff\xff\xff\x5d\xff\xff\xff\x62\xff\xff\xff\x64\xff\xff\xff\xb1\xff\xff\xff\xb2\xff\xff\xff\xbb\xff\xff\xff\xbd\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\xff\xff\xff\xd5\xff\xff\xff\xd3\xff\xff\xff\x4e\xff\xff\xff\x4c\xff\xff\xff\x4b\xff\xff\xff\xde\xff\xff\xff\xe3\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\xd1\xff\xff\xff\xb9\xff\xff\xff\x5f\xff\xff\xff\x5e\xff\xff\xff\xd2\xff\xff\xff\xdf\xff\xff\xff\x00\x00\x00\x00\xe2\xff\xff\xff\xee\xff\xff\xff"#
+
+happyCheck :: HappyAddr
+happyCheck = HappyA# "\xff\xff\xff\xff\x02\x00\x00\x00\x0a\x00\x00\x00\x04\x00\x00\x00\x0c\x00\x00\x00\x0a\x00\x00\x00\x1d\x00\x00\x00\x08\x00\x00\x00\x1d\x00\x00\x00\x20\x00\x00\x00\x10\x00\x00\x00\x20\x00\x00\x00\x2b\x00\x00\x00\x3c\x00\x00\x00\x0f\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x2e\x00\x00\x00\x2c\x00\x00\x00\x2e\x00\x00\x00\x09\x00\x00\x00\x2e\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x28\x00\x00\x00\x05\x00\x00\x00\x39\x00\x00\x00\x2c\x00\x00\x00\x39\x00\x00\x00\x5a\x00\x00\x00\x0a\x00\x00\x00\x3e\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x04\x00\x00\x00\x1b\x00\x00\x00\x2d\x00\x00\x00\x39\x00\x00\x00\x1c\x00\x00\x00\x30\x00\x00\x00\x2b\x00\x00\x00\x37\x00\x00\x00\x0b\x00\x00\x00\x04\x00\x00\x00\x18\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x0c\x00\x00\x00\x11\x00\x00\x00\x02\x00\x00\x00\x0f\x00\x00\x00\x04\x00\x00\x00\x6b\x00\x00\x00\x04\x00\x00\x00\x3f\x00\x00\x00\x08\x00\x00\x00\x41\x00\x00\x00\x60\x00\x00\x00\x1c\x00\x00\x00\x04\x00\x00\x00\x45\x00\x00\x00\x46\x00\x00\x00\x0f\x00\x00\x00\x35\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x61\x00\x00\x00\x4f\x00\x00\x00\x3d\x00\x00\x00\x3f\x00\x00\x00\x66\x00\x00\x00\x53\x00\x00\x00\x54\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x57\x00\x00\x00\x45\x00\x00\x00\x61\x00\x00\x00\x70\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x27\x00\x00\x00\x67\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x67\x00\x00\x00\x3d\x00\x00\x00\x2d\x00\x00\x00\x60\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x45\x00\x00\x00\x3d\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x45\x00\x00\x00\x3c\x00\x00\x00\x3f\x00\x00\x00\x08\x00\x00\x00\x41\x00\x00\x00\x40\x00\x00\x00\x20\x00\x00\x00\x3c\x00\x00\x00\x45\x00\x00\x00\x46\x00\x00\x00\x0f\x00\x00\x00\x40\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x67\x00\x00\x00\x4f\x00\x00\x00\x04\x00\x00\x00\x22\x00\x00\x00\x70\x00\x00\x00\x53\x00\x00\x00\x54\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x57\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x1a\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x27\x00\x00\x00\x2e\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x23\x00\x00\x00\x6b\x00\x00\x00\x2d\x00\x00\x00\x06\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x39\x00\x00\x00\x70\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x3e\x00\x00\x00\x16\x00\x00\x00\x3f\x00\x00\x00\x08\x00\x00\x00\x41\x00\x00\x00\x24\x00\x00\x00\x44\x00\x00\x00\x65\x00\x00\x00\x45\x00\x00\x00\x46\x00\x00\x00\x0f\x00\x00\x00\x51\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x19\x00\x00\x00\x4f\x00\x00\x00\x62\x00\x00\x00\x1c\x00\x00\x00\x3e\x00\x00\x00\x53\x00\x00\x00\x54\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x57\x00\x00\x00\x44\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x27\x00\x00\x00\x07\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x2d\x00\x00\x00\x1f\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x1b\x00\x00\x00\x10\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x39\x00\x00\x00\x0b\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x3e\x00\x00\x00\x04\x00\x00\x00\x3f\x00\x00\x00\x08\x00\x00\x00\x41\x00\x00\x00\x2f\x00\x00\x00\x44\x00\x00\x00\x6b\x00\x00\x00\x45\x00\x00\x00\x46\x00\x00\x00\x0f\x00\x00\x00\x17\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x04\x00\x00\x00\x4f\x00\x00\x00\x6b\x00\x00\x00\x63\x00\x00\x00\x08\x00\x00\x00\x53\x00\x00\x00\x54\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x57\x00\x00\x00\x08\x00\x00\x00\x0f\x00\x00\x00\x17\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x27\x00\x00\x00\x23\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x16\x00\x00\x00\x17\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6b\x00\x00\x00\x19\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x39\x00\x00\x00\x1f\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x3a\x00\x00\x00\x3e\x00\x00\x00\x15\x00\x00\x00\x3f\x00\x00\x00\x3e\x00\x00\x00\x41\x00\x00\x00\x47\x00\x00\x00\x44\x00\x00\x00\x23\x00\x00\x00\x45\x00\x00\x00\x46\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x3c\x00\x00\x00\x4f\x00\x00\x00\x5f\x00\x00\x00\x22\x00\x00\x00\x22\x00\x00\x00\x53\x00\x00\x00\x54\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x64\x00\x00\x00\x1c\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x02\x00\x00\x00\x19\x00\x00\x00\x04\x00\x00\x00\x6b\x00\x00\x00\x1f\x00\x00\x00\x09\x00\x00\x00\x08\x00\x00\x00\x47\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x0f\x00\x00\x00\x5b\x00\x00\x00\x1f\x00\x00\x00\x6b\x00\x00\x00\x5e\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x64\x00\x00\x00\x6b\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x65\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x1b\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x62\x00\x00\x00\x0f\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x22\x00\x00\x00\x10\x00\x00\x00\x2d\x00\x00\x00\x0b\x00\x00\x00\x64\x00\x00\x00\x30\x00\x00\x00\x18\x00\x00\x00\x64\x00\x00\x00\x1a\x00\x00\x00\x6b\x00\x00\x00\x6b\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x64\x00\x00\x00\x3d\x00\x00\x00\x02\x00\x00\x00\x38\x00\x00\x00\x04\x00\x00\x00\x60\x00\x00\x00\x35\x00\x00\x00\x3f\x00\x00\x00\x08\x00\x00\x00\x41\x00\x00\x00\x63\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x45\x00\x00\x00\x46\x00\x00\x00\x0f\x00\x00\x00\x1f\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x0c\x00\x00\x00\x4f\x00\x00\x00\x0d\x00\x00\x00\x42\x00\x00\x00\x0e\x00\x00\x00\x53\x00\x00\x00\x54\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x57\x00\x00\x00\x43\x00\x00\x00\x04\x00\x00\x00\x42\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x42\x00\x00\x00\x42\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x42\x00\x00\x00\x42\x00\x00\x00\x2d\x00\x00\x00\x37\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x04\x00\x00\x00\x12\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x14\x00\x00\x00\x38\x00\x00\x00\x02\x00\x00\x00\x38\x00\x00\x00\x04\x00\x00\x00\x38\x00\x00\x00\x38\x00\x00\x00\x3f\x00\x00\x00\x08\x00\x00\x00\x41\x00\x00\x00\x15\x00\x00\x00\x41\x00\x00\x00\x12\x00\x00\x00\x45\x00\x00\x00\x46\x00\x00\x00\x0f\x00\x00\x00\x38\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x04\x00\x00\x00\x4f\x00\x00\x00\x38\x00\x00\x00\xff\xff\xff\xff\x08\x00\x00\x00\x53\x00\x00\x00\x54\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x57\x00\x00\x00\xff\xff\xff\xff\x0f\x00\x00\x00\xff\xff\xff\xff\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x00\x00\x2a\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x00\x00\xff\xff\xff\xff\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x02\x00\x00\x00\xff\xff\xff\xff\x04\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\x00\x00\x4d\x00\x00\x00\x4e\x00\x00\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x3f\x00\x00\x00\xff\xff\xff\xff\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x11\x00\x00\x00\x4f\x00\x00\x00\x13\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x03\x00\x00\x00\x54\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x57\x00\x00\x00\xff\xff\xff\xff\x04\x00\x00\x00\xff\xff\xff\xff\x5b\x00\x00\x00\x5c\x00\x00\x00\x08\x00\x00\x00\x5e\x00\x00\x00\x4d\x00\x00\x00\xff\xff\xff\xff\x4f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\xff\xff\xff\xff\x5b\x00\x00\x00\x1e\x00\x00\x00\xff\xff\xff\xff\x5e\x00\x00\x00\x21\x00\x00\x00\xff\xff\xff\xff\x23\x00\x00\x00\xff\xff\xff\xff\x25\x00\x00\x00\x26\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x4c\x00\x00\x00\x4d\x00\x00\x00\x04\x00\x00\x00\x4f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x00\x00\x56\x00\x00\x00\x57\x00\x00\x00\xff\xff\xff\xff\x0f\x00\x00\x00\xff\xff\xff\xff\x5b\x00\x00\x00\x5c\x00\x00\x00\xff\xff\xff\xff\x5e\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x00\x00\xff\xff\xff\xff\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\x00\x00\x4d\x00\x00\x00\xff\xff\xff\xff\x4f\x00\x00\x00\xff\xff\xff\xff\x56\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x00\x00\x56\x00\x00\x00\x57\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x00\x00\x5c\x00\x00\x00\x40\x00\x00\x00\x5e\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x00\x00\xff\xff\xff\xff\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x52\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x00\x00\xff\xff\xff\xff\x67\x00\x00\x00\x5e\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\x00\x00\xff\xff\xff\xff\x13\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x00\x00\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x46\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x3b\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x39\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\x3e\x00\x00\x00\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\x45\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x45\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x3d\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\x45\x00\x00\x00\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x45\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x1c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x1c\x00\x00\x00\x3d\x00\x00\x00\x45\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x1c\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x00\x00\x45\x00\x00\x00\xff\xff\xff\xff\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\xff\xff\xff\xff\x34\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\x35\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\x3d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
+
+happyTable :: HappyAddr
+happyTable = HappyA# "\x00\x00\x00\x00\x4d\x00\x00\x00\x7f\x00\x00\x00\x4e\x00\x00\x00\x80\x00\x00\x00\x06\x01\x00\x00\x19\x00\x00\x00\x4f\x00\x00\x00\x31\x01\x00\x00\x09\x00\x00\x00\x3a\x01\x00\x00\x09\x00\x00\x00\xbe\x00\x00\x00\x9a\x00\x00\x00\x50\x00\x00\x00\xd2\x00\x00\x00\x03\x01\x00\x00\x10\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x0d\x00\x00\x00\xbc\x00\x00\x00\x0d\x00\x00\x00\x10\x00\x00\x00\x0d\x00\x00\x00\x1a\x00\x00\x00\x10\x00\x00\x00\x1a\x00\x00\x00\x10\x00\x00\x00\x81\x00\x00\x00\xaf\x00\x00\x00\x0b\x00\x00\x00\xbc\x00\x00\x00\x0b\x00\x00\x00\xd3\x00\x00\x00\xb0\x00\x00\x00\x1b\x00\x00\x00\x51\x00\x00\x00\x52\x00\x00\x00\x2b\x00\x00\x00\x04\x01\x00\x00\x53\x00\x00\x00\x0b\x00\x00\x00\x2c\x00\x00\x00\x54\x00\x00\x00\xbe\x00\x00\x00\x3b\x01\x00\x00\x0d\x00\x00\x00\x2b\x00\x00\x00\xb1\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\xb2\x00\x00\x00\x0e\x00\x00\x00\x4d\x00\x00\x00\xb3\x00\x00\x00\x4e\x00\x00\x00\x6d\x00\x00\x00\x08\x01\x00\x00\x57\x00\x00\x00\x4f\x00\x00\x00\x58\x00\x00\x00\xbf\x00\x00\x00\x7a\x00\x00\x00\x08\x01\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x50\x00\x00\x00\xf0\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\xbd\x00\x00\x00\x60\x00\x00\x00\x47\x00\x00\x00\x11\x00\x00\x00\x32\x01\x00\x00\x61\x00\x00\x00\x62\x00\x00\x00\x63\x00\x00\x00\x64\x00\x00\x00\x65\x00\x00\x00\x48\x00\x00\x00\xbd\x00\x00\x00\xf1\xff\xff\xff\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\xce\x00\x00\x00\x07\x00\x00\x00\x51\x00\x00\x00\x52\x00\x00\x00\x07\x00\x00\x00\x47\x00\x00\x00\x53\x00\x00\x00\xbf\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x48\x00\x00\x00\x47\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\xab\x00\x00\x00\xac\x00\x00\x00\x4d\x00\x00\x00\x8d\x00\x00\x00\x4e\x00\x00\x00\xf3\x00\x00\x00\x09\x01\x00\x00\x57\x00\x00\x00\x4f\x00\x00\x00\x58\x00\x00\x00\x0a\x01\x00\x00\x09\x00\x00\x00\x09\x01\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x50\x00\x00\x00\x2e\x01\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x07\x00\x00\x00\x60\x00\x00\x00\x8d\x00\x00\x00\xc4\x00\x00\x00\xff\xff\xff\xff\x61\x00\x00\x00\x62\x00\x00\x00\x63\x00\x00\x00\x64\x00\x00\x00\x65\x00\x00\x00\x23\x01\x00\x00\x24\x01\x00\x00\x35\x01\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\xcd\x00\x00\x00\x1e\x00\x00\x00\x51\x00\x00\x00\x52\x00\x00\x00\x36\x01\x00\x00\x6d\x00\x00\x00\x53\x00\x00\x00\xa7\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\xab\x00\x00\x00\xac\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x96\x00\x00\x00\xff\xff\xff\xff\x4d\x00\x00\x00\x8d\x00\x00\x00\x4e\x00\x00\x00\x97\x00\x00\x00\xa8\x00\x00\x00\x57\x00\x00\x00\x4f\x00\x00\x00\x58\x00\x00\x00\xc3\x00\x00\x00\x98\x00\x00\x00\xc2\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x50\x00\x00\x00\xc5\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x53\xff\xff\xff\x60\x00\x00\x00\xc1\x00\x00\x00\x53\xff\xff\xff\x97\x00\x00\x00\x61\x00\x00\x00\x62\x00\x00\x00\x63\x00\x00\x00\x64\x00\x00\x00\x65\x00\x00\x00\x1a\x01\x00\x00\x12\x01\x00\x00\x13\x01\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\xcc\x00\x00\x00\xc0\x00\x00\x00\x51\x00\x00\x00\x52\x00\x00\x00\xab\x00\x00\x00\xac\x00\x00\x00\x53\x00\x00\x00\xae\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\xad\x00\x00\x00\xaa\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\xf5\x00\x00\x00\xa9\x00\x00\x00\x4d\x00\x00\x00\x8d\x00\x00\x00\x4e\x00\x00\x00\x97\x00\x00\x00\x8d\x00\x00\x00\x57\x00\x00\x00\x4f\x00\x00\x00\x58\x00\x00\x00\xa2\x00\x00\x00\x98\x00\x00\x00\x6d\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x50\x00\x00\x00\x84\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x4e\x00\x00\x00\x60\x00\x00\x00\x6d\x00\x00\x00\x0d\x01\x00\x00\x4f\x00\x00\x00\x61\x00\x00\x00\x62\x00\x00\x00\x63\x00\x00\x00\x64\x00\x00\x00\x65\x00\x00\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x84\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\xcb\x00\x00\x00\x82\x00\x00\x00\x51\x00\x00\x00\x52\x00\x00\x00\x32\x01\x00\x00\x33\x01\x00\x00\x53\x00\x00\x00\x7b\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x6d\x00\x00\x00\x08\x01\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\xf1\x00\x00\x00\xae\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x8e\x00\x00\x00\x97\x00\x00\x00\xc9\x00\x00\x00\x57\x00\x00\x00\x8f\x00\x00\x00\x58\x00\x00\x00\x00\x01\x00\x00\x98\x00\x00\x00\xff\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x7c\x00\x00\x00\x7d\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\xa6\x00\x00\x00\x60\x00\x00\x00\xfe\x00\x00\x00\xc4\x00\x00\x00\xc4\x00\x00\x00\x61\x00\x00\x00\x62\x00\x00\x00\x63\x00\x00\x00\x64\x00\x00\x00\x65\x00\x00\x00\x7b\x00\x00\x00\xf9\x00\x00\x00\xf8\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x4d\x00\x00\x00\xf7\x00\x00\x00\x4e\x00\x00\x00\x6d\x00\x00\x00\xae\x00\x00\x00\xf5\x00\x00\x00\x4f\x00\x00\x00\xdd\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x50\x00\x00\x00\x66\x00\x00\x00\xae\x00\x00\x00\x6d\x00\x00\x00\x69\x00\x00\x00\x2d\x01\x00\x00\x7d\x00\x00\x00\xf3\x00\x00\x00\x6d\x00\x00\x00\xc3\x00\x00\x00\x6d\x00\x00\x00\xc0\x00\x00\x00\xc2\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\xad\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\xc1\x00\x00\x00\x6e\x00\x00\x00\x51\x00\x00\x00\x52\x00\x00\x00\xc4\x00\x00\x00\xaa\x00\x00\x00\x53\x00\x00\x00\xa9\x00\x00\x00\x1f\x01\x00\x00\xca\x00\x00\x00\x6f\x00\x00\x00\x1d\x01\x00\x00\x70\x00\x00\x00\x6d\x00\x00\x00\x6d\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x0f\x01\x00\x00\x2b\x01\x00\x00\x4d\x00\x00\x00\x2a\x01\x00\x00\x4e\x00\x00\x00\x29\x01\x00\x00\xfb\x00\x00\x00\x57\x00\x00\x00\x4f\x00\x00\x00\x58\x00\x00\x00\x0d\x01\x00\x00\xfc\x00\x00\x00\xfd\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x50\x00\x00\x00\xae\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x0b\x00\x00\x00\x60\x00\x00\x00\x09\x00\x00\x00\x1c\x00\x00\x00\x07\x00\x00\x00\x61\x00\x00\x00\x62\x00\x00\x00\x63\x00\x00\x00\x64\x00\x00\x00\x65\x00\x00\x00\x1b\x00\x00\x00\x79\x00\x00\x00\x26\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x25\x00\x00\x00\x24\x00\x00\x00\x51\x00\x00\x00\x52\x00\x00\x00\x23\x00\x00\x00\x22\x00\x00\x00\x53\x00\x00\x00\xc5\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x82\x00\x00\x00\x0b\x01\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x06\x01\x00\x00\x02\x01\x00\x00\x4d\x00\x00\x00\x01\x01\x00\x00\x4e\x00\x00\x00\x00\x01\x00\x00\xf9\x00\x00\x00\x57\x00\x00\x00\x4f\x00\x00\x00\x58\x00\x00\x00\x10\x01\x00\x00\x0d\x01\x00\x00\x3d\x01\x00\x00\x59\x00\x00\x00\x5a\x00\x00\x00\x50\x00\x00\x00\x25\x01\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x4e\x00\x00\x00\x60\x00\x00\x00\x24\x01\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x61\x00\x00\x00\x62\x00\x00\x00\x63\x00\x00\x00\x64\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x52\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x15\x00\x00\x00\x16\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x0e\x00\x00\x00\x60\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\x62\x00\x00\x00\x63\x00\x00\x00\x64\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x4f\x00\x00\x00\x69\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\xb8\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x4e\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x00\x00\x64\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x00\x00\x64\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x72\x00\x00\x00\x69\x00\x00\x00\x73\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x00\x00\x78\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x00\x00\x6c\x00\x00\x00\x6d\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x15\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x2f\x01\x00\x00\x2c\x00\x00\x00\x9e\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\xd0\x00\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\xce\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\xcf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x39\x01\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x3c\x01\x00\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x1d\x01\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x19\x01\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x15\x01\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x13\x01\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x27\x01\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x26\x01\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x36\x01\x00\x00\x2f\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x01\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x01\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x00\x00\x00\x32\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x9c\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x9b\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x9a\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x94\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x92\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x88\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\xdb\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\xda\x00\x00\x00\x38\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x18\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x17\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x16\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x38\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x37\x01\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\xe2\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x1f\x01\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x01\x00\x00\x3b\x00\x00\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x97\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x48\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x00\x00\x3e\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x3f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x9f\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x9d\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x87\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x2c\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x84\x00\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x1b\x01\x00\x00\x40\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x47\x00\x00\x00\xea\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x41\x00\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x2c\x01\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x01\x00\x00\x42\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x47\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x47\x00\x00\x00\x48\x00\x00\x00\xec\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x2c\x00\x00\x00\xee\x00\x00\x00\x45\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\xeb\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\xed\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x0f\x01\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\xef\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
+
+happyReduceArr = Happy_Data_Array.array (5, 191) [
+        (5 , happyReduce_5),
+        (6 , happyReduce_6),
+        (7 , happyReduce_7),
+        (8 , happyReduce_8),
+        (9 , happyReduce_9),
+        (10 , happyReduce_10),
+        (11 , happyReduce_11),
+        (12 , happyReduce_12),
+        (13 , happyReduce_13),
+        (14 , happyReduce_14),
+        (15 , happyReduce_15),
+        (16 , happyReduce_16),
+        (17 , happyReduce_17),
+        (18 , happyReduce_18),
+        (19 , happyReduce_19),
+        (20 , happyReduce_20),
+        (21 , happyReduce_21),
+        (22 , happyReduce_22),
+        (23 , happyReduce_23),
+        (24 , happyReduce_24),
+        (25 , happyReduce_25),
+        (26 , happyReduce_26),
+        (27 , happyReduce_27),
+        (28 , happyReduce_28),
+        (29 , happyReduce_29),
+        (30 , happyReduce_30),
+        (31 , happyReduce_31),
+        (32 , happyReduce_32),
+        (33 , happyReduce_33),
+        (34 , happyReduce_34),
+        (35 , happyReduce_35),
+        (36 , happyReduce_36),
+        (37 , happyReduce_37),
+        (38 , happyReduce_38),
+        (39 , happyReduce_39),
+        (40 , happyReduce_40),
+        (41 , happyReduce_41),
+        (42 , happyReduce_42),
+        (43 , happyReduce_43),
+        (44 , happyReduce_44),
+        (45 , happyReduce_45),
+        (46 , happyReduce_46),
+        (47 , happyReduce_47),
+        (48 , happyReduce_48),
+        (49 , happyReduce_49),
+        (50 , happyReduce_50),
+        (51 , happyReduce_51),
+        (52 , happyReduce_52),
+        (53 , happyReduce_53),
+        (54 , happyReduce_54),
+        (55 , happyReduce_55),
+        (56 , happyReduce_56),
+        (57 , happyReduce_57),
+        (58 , happyReduce_58),
+        (59 , happyReduce_59),
+        (60 , happyReduce_60),
+        (61 , happyReduce_61),
+        (62 , happyReduce_62),
+        (63 , happyReduce_63),
+        (64 , happyReduce_64),
+        (65 , happyReduce_65),
+        (66 , happyReduce_66),
+        (67 , happyReduce_67),
+        (68 , happyReduce_68),
+        (69 , happyReduce_69),
+        (70 , happyReduce_70),
+        (71 , happyReduce_71),
+        (72 , happyReduce_72),
+        (73 , happyReduce_73),
+        (74 , happyReduce_74),
+        (75 , happyReduce_75),
+        (76 , happyReduce_76),
+        (77 , happyReduce_77),
+        (78 , happyReduce_78),
+        (79 , happyReduce_79),
+        (80 , happyReduce_80),
+        (81 , happyReduce_81),
+        (82 , happyReduce_82),
+        (83 , happyReduce_83),
+        (84 , happyReduce_84),
+        (85 , happyReduce_85),
+        (86 , happyReduce_86),
+        (87 , happyReduce_87),
+        (88 , happyReduce_88),
+        (89 , happyReduce_89),
+        (90 , happyReduce_90),
+        (91 , happyReduce_91),
+        (92 , happyReduce_92),
+        (93 , happyReduce_93),
+        (94 , happyReduce_94),
+        (95 , happyReduce_95),
+        (96 , happyReduce_96),
+        (97 , happyReduce_97),
+        (98 , happyReduce_98),
+        (99 , happyReduce_99),
+        (100 , happyReduce_100),
+        (101 , happyReduce_101),
+        (102 , happyReduce_102),
+        (103 , happyReduce_103),
+        (104 , happyReduce_104),
+        (105 , happyReduce_105),
+        (106 , happyReduce_106),
+        (107 , happyReduce_107),
+        (108 , happyReduce_108),
+        (109 , happyReduce_109),
+        (110 , happyReduce_110),
+        (111 , happyReduce_111),
+        (112 , happyReduce_112),
+        (113 , happyReduce_113),
+        (114 , happyReduce_114),
+        (115 , happyReduce_115),
+        (116 , happyReduce_116),
+        (117 , happyReduce_117),
+        (118 , happyReduce_118),
+        (119 , happyReduce_119),
+        (120 , happyReduce_120),
+        (121 , happyReduce_121),
+        (122 , happyReduce_122),
+        (123 , happyReduce_123),
+        (124 , happyReduce_124),
+        (125 , happyReduce_125),
+        (126 , happyReduce_126),
+        (127 , happyReduce_127),
+        (128 , happyReduce_128),
+        (129 , happyReduce_129),
+        (130 , happyReduce_130),
+        (131 , happyReduce_131),
+        (132 , happyReduce_132),
+        (133 , happyReduce_133),
+        (134 , happyReduce_134),
+        (135 , happyReduce_135),
+        (136 , happyReduce_136),
+        (137 , happyReduce_137),
+        (138 , happyReduce_138),
+        (139 , happyReduce_139),
+        (140 , happyReduce_140),
+        (141 , happyReduce_141),
+        (142 , happyReduce_142),
+        (143 , happyReduce_143),
+        (144 , happyReduce_144),
+        (145 , happyReduce_145),
+        (146 , happyReduce_146),
+        (147 , happyReduce_147),
+        (148 , happyReduce_148),
+        (149 , happyReduce_149),
+        (150 , happyReduce_150),
+        (151 , happyReduce_151),
+        (152 , happyReduce_152),
+        (153 , happyReduce_153),
+        (154 , happyReduce_154),
+        (155 , happyReduce_155),
+        (156 , happyReduce_156),
+        (157 , happyReduce_157),
+        (158 , happyReduce_158),
+        (159 , happyReduce_159),
+        (160 , happyReduce_160),
+        (161 , happyReduce_161),
+        (162 , happyReduce_162),
+        (163 , happyReduce_163),
+        (164 , happyReduce_164),
+        (165 , happyReduce_165),
+        (166 , happyReduce_166),
+        (167 , happyReduce_167),
+        (168 , happyReduce_168),
+        (169 , happyReduce_169),
+        (170 , happyReduce_170),
+        (171 , happyReduce_171),
+        (172 , happyReduce_172),
+        (173 , happyReduce_173),
+        (174 , happyReduce_174),
+        (175 , happyReduce_175),
+        (176 , happyReduce_176),
+        (177 , happyReduce_177),
+        (178 , happyReduce_178),
+        (179 , happyReduce_179),
+        (180 , happyReduce_180),
+        (181 , happyReduce_181),
+        (182 , happyReduce_182),
+        (183 , happyReduce_183),
+        (184 , happyReduce_184),
+        (185 , happyReduce_185),
+        (186 , happyReduce_186),
+        (187 , happyReduce_187),
+        (188 , happyReduce_188),
+        (189 , happyReduce_189),
+        (190 , happyReduce_190),
+        (191 , happyReduce_191)
+        ]
+
+happyRuleArr :: HappyAddr
+happyRuleArr = HappyA# "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x00\x0a\x00\x00\x00\x04\x00\x00\x00\x0a\x00\x00\x00\x01\x00\x00\x00\x0b\x00\x00\x00\x0a\x00\x00\x00\x0c\x00\x00\x00\x03\x00\x00\x00\x0d\x00\x00\x00\x04\x00\x00\x00\x0e\x00\x00\x00\x04\x00\x00\x00\x0e\x00\x00\x00\x04\x00\x00\x00\x0e\x00\x00\x00\x04\x00\x00\x00\x0e\x00\x00\x00\x04\x00\x00\x00\x0f\x00\x00\x00\x01\x00\x00\x00\x0f\x00\x00\x00\x01\x00\x00\x00\x0f\x00\x00\x00\x01\x00\x00\x00\x0f\x00\x00\x00\x01\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x02\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x01\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x03\x00\x00\x00\x13\x00\x00\x00\x01\x00\x00\x00\x13\x00\x00\x00\x04\x00\x00\x00\x13\x00\x00\x00\x01\x00\x00\x00\x13\x00\x00\x00\x01\x00\x00\x00\x13\x00\x00\x00\x01\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x02\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x02\x00\x00\x00\x15\x00\x00\x00\x02\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x02\x00\x00\x00\x17\x00\x00\x00\x01\x00\x00\x00\x17\x00\x00\x00\x01\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x01\x00\x00\x00\x18\x00\x00\x00\x01\x00\x00\x00\x18\x00\x00\x00\x01\x00\x00\x00\x18\x00\x00\x00\x01\x00\x00\x00\x18\x00\x00\x00\x01\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x01\x00\x00\x00\x19\x00\x00\x00\x01\x00\x00\x00\x19\x00\x00\x00\x01\x00\x00\x00\x19\x00\x00\x00\x01\x00\x00\x00\x19\x00\x00\x00\x01\x00\x00\x00\x1a\x00\x00\x00\x03\x00\x00\x00\x1b\x00\x00\x00\x01\x00\x00\x00\x1b\x00\x00\x00\x01\x00\x00\x00\x1c\x00\x00\x00\x01\x00\x00\x00\x1d\x00\x00\x00\x03\x00\x00\x00\x1d\x00\x00\x00\x01\x00\x00\x00\x1e\x00\x00\x00\x05\x00\x00\x00\x1e\x00\x00\x00\x04\x00\x00\x00\x1e\x00\x00\x00\x05\x00\x00\x00\x1e\x00\x00\x00\x04\x00\x00\x00\x1e\x00\x00\x00\x06\x00\x00\x00\x1e\x00\x00\x00\x04\x00\x00\x00\x1e\x00\x00\x00\x01\x00\x00\x00\x1f\x00\x00\x00\x03\x00\x00\x00\x1f\x00\x00\x00\x03\x00\x00\x00\x1f\x00\x00\x00\x03\x00\x00\x00\x1f\x00\x00\x00\x03\x00\x00\x00\x1f\x00\x00\x00\x05\x00\x00\x00\x1f\x00\x00\x00\x05\x00\x00\x00\x1f\x00\x00\x00\x02\x00\x00\x00\x1f\x00\x00\x00\x02\x00\x00\x00\x1f\x00\x00\x00\x01\x00\x00\x00\x20\x00\x00\x00\x03\x00\x00\x00\x20\x00\x00\x00\x01\x00\x00\x00\x21\x00\x00\x00\x03\x00\x00\x00\x21\x00\x00\x00\x01\x00\x00\x00\x22\x00\x00\x00\x03\x00\x00\x00\x22\x00\x00\x00\x01\x00\x00\x00\x23\x00\x00\x00\x03\x00\x00\x00\x23\x00\x00\x00\x01\x00\x00\x00\x24\x00\x00\x00\x03\x00\x00\x00\x24\x00\x00\x00\x01\x00\x00\x00\x25\x00\x00\x00\x03\x00\x00\x00\x25\x00\x00\x00\x03\x00\x00\x00\x25\x00\x00\x00\x01\x00\x00\x00\x26\x00\x00\x00\x03\x00\x00\x00\x26\x00\x00\x00\x03\x00\x00\x00\x26\x00\x00\x00\x01\x00\x00\x00\x27\x00\x00\x00\x02\x00\x00\x00\x27\x00\x00\x00\x02\x00\x00\x00\x27\x00\x00\x00\x02\x00\x00\x00\x27\x00\x00\x00\x02\x00\x00\x00\x27\x00\x00\x00\x02\x00\x00\x00\x27\x00\x00\x00\x02\x00\x00\x00\x27\x00\x00\x00\x01\x00\x00\x00\x28\x00\x00\x00\x02\x00\x00\x00\x28\x00\x00\x00\x01\x00\x00\x00\x29\x00\x00\x00\x03\x00\x00\x00\x29\x00\x00\x00\x03\x00\x00\x00\x29\x00\x00\x00\x03\x00\x00\x00\x29\x00\x00\x00\x03\x00\x00\x00\x29\x00\x00\x00\x03\x00\x00\x00\x29\x00\x00\x00\x03\x00\x00\x00\x29\x00\x00\x00\x03\x00\x00\x00\x29\x00\x00\x00\x04\x00\x00\x00\x29\x00\x00\x00\x01\x00\x00\x00\x2a\x00\x00\x00\x02\x00\x00\x00\x2a\x00\x00\x00\x01\x00\x00\x00\x2b\x00\x00\x00\x03\x00\x00\x00\x2b\x00\x00\x00\x03\x00\x00\x00\x2b\x00\x00\x00\x01\x00\x00\x00\x2c\x00\x00\x00\x03\x00\x00\x00\x2c\x00\x00\x00\x03\x00\x00\x00\x2c\x00\x00\x00\x03\x00\x00\x00\x2c\x00\x00\x00\x01\x00\x00\x00\x2d\x00\x00\x00\x02\x00\x00\x00\x2d\x00\x00\x00\x02\x00\x00\x00\x2d\x00\x00\x00\x01\x00\x00\x00\x2e\x00\x00\x00\x02\x00\x00\x00\x2e\x00\x00\x00\x02\x00\x00\x00\x2e\x00\x00\x00\x02\x00\x00\x00\x2e\x00\x00\x00\x02\x00\x00\x00\x2e\x00\x00\x00\x01\x00\x00\x00\x2f\x00\x00\x00\x03\x00\x00\x00\x2f\x00\x00\x00\x01\x00\x00\x00\x30\x00\x00\x00\x03\x00\x00\x00\x30\x00\x00\x00\x01\x00\x00\x00\x31\x00\x00\x00\x03\x00\x00\x00\x31\x00\x00\x00\x03\x00\x00\x00\x31\x00\x00\x00\x01\x00\x00\x00\x32\x00\x00\x00\x03\x00\x00\x00\x32\x00\x00\x00\x01\x00\x00\x00\x33\x00\x00\x00\x03\x00\x00\x00\x33\x00\x00\x00\x01\x00\x00\x00\x34\x00\x00\x00\x03\x00\x00\x00\x34\x00\x00\x00\x03\x00\x00\x00\x34\x00\x00\x00\x01\x00\x00\x00\x35\x00\x00\x00\x01\x00\x00\x00\x35\x00\x00\x00\x01\x00\x00\x00\x35\x00\x00\x00\x01\x00\x00\x00\x35\x00\x00\x00\x01\x00\x00\x00\x35\x00\x00\x00\x01\x00\x00\x00\x35\x00\x00\x00\x03\x00\x00\x00\x36\x00\x00\x00\x01\x00\x00\x00\x37\x00\x00\x00\x01\x00\x00\x00\x37\x00\x00\x00\x03\x00\x00\x00\x37\x00\x00\x00\x01\x00\x00\x00\x37\x00\x00\x00\x03\x00\x00\x00\x38\x00\x00\x00\x02\x00\x00\x00\x38\x00\x00\x00\x02\x00\x00\x00\x38\x00\x00\x00\x04\x00\x00\x00\x38\x00\x00\x00\x04\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x03\x00\x00\x00\x3a\x00\x00\x00\x03\x00\x00\x00\x3b\x00\x00\x00\x01\x00\x00\x00\x3b\x00\x00\x00\x01\x00\x00\x00\x3b\x00\x00\x00\x01\x00\x00\x00\x3b\x00\x00\x00\x01\x00\x00\x00\x3b\x00\x00\x00\x01\x00\x00\x00\x3c\x00\x00\x00\x01\x00\x00\x00\x3d\x00\x00\x00\x01\x00\x00\x00\x3e\x00\x00\x00\x01\x00\x00\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x02\x00\x00\x00\x3f\x00\x00\x00\x02\x00\x00\x00\x40\x00\x00\x00\x01\x00\x00\x00\x40\x00\x00\x00\x03\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x02\x00\x00\x00\x41\x00\x00\x00\x02\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x02\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x02\x00\x00\x00\x44\x00\x00\x00\x01\x00\x00\x00\x44\x00\x00\x00\x03\x00\x00\x00\x45\x00\x00\x00\x01\x00\x00\x00\x45\x00\x00\x00\x03\x00\x00\x00\x46\x00\x00\x00\x01\x00\x00\x00\x47\x00\x00\x00\x01\x00\x00\x00\x48\x00\x00\x00\x01\x00\x00\x00"#
+
+happyCatchStates :: [Happy_Prelude.Int]
+happyCatchStates = []
+
+happy_n_terms = 113 :: Happy_Prelude.Int
+happy_n_nonterms = 73 :: Happy_Prelude.Int
+
+happy_n_starts = 5 :: Happy_Prelude.Int
+
+happyReduce_5 = happySpecReduce_1  0# happyReduction_5
+happyReduction_5 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn9
+                 (PosInteger (mkPosToken happy_var_1)
+        )}
+
+happyReduce_6 = happySpecReduce_1  1# happyReduction_6
+happyReduction_6 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn10
+                 (PosDouble (mkPosToken happy_var_1)
+        )}
+
+happyReduce_7 = happySpecReduce_1  2# happyReduction_7
+happyReduction_7 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn11
+                 (PosReal (mkPosToken happy_var_1)
+        )}
+
+happyReduce_8 = happySpecReduce_1  3# happyReduction_8
+happyReduction_8 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn12
+                 (PosString (mkPosToken happy_var_1)
+        )}
+
+happyReduce_9 = happySpecReduce_1  4# happyReduction_9
+happyReduction_9 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn13
+                 (PosIdent (mkPosToken happy_var_1)
+        )}
+
+happyReduce_10 = happySpecReduce_1  5# happyReduction_10
+happyReduction_10 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn14
+                 (PosLineComment (mkPosToken happy_var_1)
+        )}
+
+happyReduce_11 = happySpecReduce_1  6# happyReduction_11
+happyReduction_11 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn15
+                 (PosBlockComment (mkPosToken happy_var_1)
+        )}
+
+happyReduce_12 = happySpecReduce_1  7# happyReduction_12
+happyReduction_12 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn16
+                 (PosAlloy (mkPosToken happy_var_1)
+        )}
+
+happyReduce_13 = happySpecReduce_1  8# happyReduction_13
+happyReduction_13 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn17
+                 (PosChoco (mkPosToken happy_var_1)
+        )}
+
+happyReduce_14 = happySpecReduce_1  9# happyReduction_14
+happyReduction_14 happy_x_1
+         =  case happyOut72 happy_x_1 of { (HappyWrap72 happy_var_1) -> 
+        happyIn18
+                 (Language.Clafer.Front.AbsClafer.Module ((mkCatSpan happy_var_1)) (reverse happy_var_1)
+        )}
+
+happyReduce_15 = happyReduce 4# 10# happyReduction_15
+happyReduction_15 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut13 happy_x_2 of { (HappyWrap13 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        case happyOut73 happy_x_4 of { (HappyWrap73 happy_var_4) -> 
+        happyIn19
+                 (Language.Clafer.Front.AbsClafer.EnumDecl ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_4
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_16 = happySpecReduce_1  10# happyReduction_16
+happyReduction_16 happy_x_1
+         =  case happyOut28 happy_x_1 of { (HappyWrap28 happy_var_1) -> 
+        happyIn19
+                 (Language.Clafer.Front.AbsClafer.ElementDecl ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_17 = happyReduce 10# 11# happyReduction_17
+happyReduction_17 (happy_x_10 `HappyStk`
+        happy_x_9 `HappyStk`
+        happy_x_8 `HappyStk`
+        happy_x_7 `HappyStk`
+        happy_x_6 `HappyStk`
+        happy_x_5 `HappyStk`
+        happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOut26 happy_x_1 of { (HappyWrap26 happy_var_1) -> 
+        case happyOut76 happy_x_2 of { (HappyWrap76 happy_var_2) -> 
+        case happyOut33 happy_x_3 of { (HappyWrap33 happy_var_3) -> 
+        case happyOut13 happy_x_4 of { (HappyWrap13 happy_var_4) -> 
+        case happyOut29 happy_x_5 of { (HappyWrap29 happy_var_5) -> 
+        case happyOut30 happy_x_6 of { (HappyWrap30 happy_var_6) -> 
+        case happyOut34 happy_x_7 of { (HappyWrap34 happy_var_7) -> 
+        case happyOut31 happy_x_8 of { (HappyWrap31 happy_var_8) -> 
+        case happyOut25 happy_x_9 of { (HappyWrap25 happy_var_9) -> 
+        case happyOut27 happy_x_10 of { (HappyWrap27 happy_var_10) -> 
+        happyIn20
+                 (Language.Clafer.Front.AbsClafer.Clafer ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkCatSpan happy_var_4) >- (mkCatSpan happy_var_5) >- (mkCatSpan happy_var_6) >- (mkCatSpan happy_var_7) >- (mkCatSpan happy_var_8) >- (mkCatSpan happy_var_9) >- (mkCatSpan happy_var_10)) happy_var_1 (reverse happy_var_2) happy_var_3 happy_var_4 happy_var_5 happy_var_6 happy_var_7 happy_var_8 happy_var_9 happy_var_10
+        ) `HappyStk` happyRest}}}}}}}}}}
+
+happyReduce_18 = happySpecReduce_3  12# happyReduction_18
+happyReduction_18 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut75 happy_x_2 of { (HappyWrap75 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        happyIn21
+                 (Language.Clafer.Front.AbsClafer.Constraint ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3)) (reverse happy_var_2)
+        )}}}
+
+happyReduce_19 = happyReduce 4# 13# happyReduction_19
+happyReduction_19 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut75 happy_x_3 of { (HappyWrap75 happy_var_3) -> 
+        case happyOutTok happy_x_4 of { happy_var_4 -> 
+        happyIn22
+                 (Language.Clafer.Front.AbsClafer.Assertion ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4)) (reverse happy_var_3)
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_20 = happyReduce 4# 14# happyReduction_20
+happyReduction_20 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut75 happy_x_3 of { (HappyWrap75 happy_var_3) -> 
+        case happyOutTok happy_x_4 of { happy_var_4 -> 
+        happyIn23
+                 (Language.Clafer.Front.AbsClafer.GoalMinDeprecated ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4)) (reverse happy_var_3)
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_21 = happyReduce 4# 14# happyReduction_21
+happyReduction_21 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut75 happy_x_3 of { (HappyWrap75 happy_var_3) -> 
+        case happyOutTok happy_x_4 of { happy_var_4 -> 
+        happyIn23
+                 (Language.Clafer.Front.AbsClafer.GoalMaxDeprecated ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4)) (reverse happy_var_3)
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_22 = happyReduce 4# 14# happyReduction_22
+happyReduction_22 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut75 happy_x_3 of { (HappyWrap75 happy_var_3) -> 
+        case happyOutTok happy_x_4 of { happy_var_4 -> 
+        happyIn23
+                 (Language.Clafer.Front.AbsClafer.GoalMinimize ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4)) (reverse happy_var_3)
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_23 = happyReduce 4# 14# happyReduction_23
+happyReduction_23 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut75 happy_x_3 of { (HappyWrap75 happy_var_3) -> 
+        case happyOutTok happy_x_4 of { happy_var_4 -> 
+        happyIn23
+                 (Language.Clafer.Front.AbsClafer.GoalMaximize ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4)) (reverse happy_var_3)
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_24 = happySpecReduce_1  15# happyReduction_24
+happyReduction_24 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn24
+                 (Language.Clafer.Front.AbsClafer.Initial ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_25 = happySpecReduce_1  15# happyReduction_25
+happyReduction_25 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn24
+                 (Language.Clafer.Front.AbsClafer.Final ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_26 = happySpecReduce_1  15# happyReduction_26
+happyReduction_26 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn24
+                 (Language.Clafer.Front.AbsClafer.FinalRef ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_27 = happySpecReduce_1  15# happyReduction_27
+happyReduction_27 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn24
+                 (Language.Clafer.Front.AbsClafer.FinalTarget ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_28 = happySpecReduce_0  16# happyReduction_28
+happyReduction_28  =  happyIn25
+                 (Language.Clafer.Front.AbsClafer.TransitionEmpty noSpan
+        )
+
+happyReduce_29 = happySpecReduce_2  16# happyReduction_29
+happyReduction_29 happy_x_2
+        happy_x_1
+         =  case happyOut64 happy_x_1 of { (HappyWrap64 happy_var_1) -> 
+        case happyOut38 happy_x_2 of { (HappyWrap38 happy_var_2) -> 
+        happyIn25
+                 (Language.Clafer.Front.AbsClafer.Transition ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_1 happy_var_2
+        )}}
+
+happyReduce_30 = happySpecReduce_0  17# happyReduction_30
+happyReduction_30  =  happyIn26
+                 (Language.Clafer.Front.AbsClafer.AbstractEmpty noSpan
+        )
+
+happyReduce_31 = happySpecReduce_1  17# happyReduction_31
+happyReduction_31 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn26
+                 (Language.Clafer.Front.AbsClafer.Abstract ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_32 = happySpecReduce_0  18# happyReduction_32
+happyReduction_32  =  happyIn27
+                 (Language.Clafer.Front.AbsClafer.ElementsEmpty noSpan
+        )
+
+happyReduce_33 = happySpecReduce_3  18# happyReduction_33
+happyReduction_33 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut74 happy_x_2 of { (HappyWrap74 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        happyIn27
+                 (Language.Clafer.Front.AbsClafer.ElementsList ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3)) (reverse happy_var_2)
+        )}}}
+
+happyReduce_34 = happySpecReduce_1  19# happyReduction_34
+happyReduction_34 happy_x_1
+         =  case happyOut20 happy_x_1 of { (HappyWrap20 happy_var_1) -> 
+        happyIn28
+                 (Language.Clafer.Front.AbsClafer.Subclafer ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_35 = happyReduce 4# 19# happyReduction_35
+happyReduction_35 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut37 happy_x_2 of { (HappyWrap37 happy_var_2) -> 
+        case happyOut34 happy_x_3 of { (HappyWrap34 happy_var_3) -> 
+        case happyOut27 happy_x_4 of { (HappyWrap27 happy_var_4) -> 
+        happyIn28
+                 (Language.Clafer.Front.AbsClafer.ClaferUse ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_3 happy_var_4
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_36 = happySpecReduce_1  19# happyReduction_36
+happyReduction_36 happy_x_1
+         =  case happyOut21 happy_x_1 of { (HappyWrap21 happy_var_1) -> 
+        happyIn28
+                 (Language.Clafer.Front.AbsClafer.Subconstraint ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_37 = happySpecReduce_1  19# happyReduction_37
+happyReduction_37 happy_x_1
+         =  case happyOut23 happy_x_1 of { (HappyWrap23 happy_var_1) -> 
+        happyIn28
+                 (Language.Clafer.Front.AbsClafer.Subgoal ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_38 = happySpecReduce_1  19# happyReduction_38
+happyReduction_38 happy_x_1
+         =  case happyOut22 happy_x_1 of { (HappyWrap22 happy_var_1) -> 
+        happyIn28
+                 (Language.Clafer.Front.AbsClafer.SubAssertion ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_39 = happySpecReduce_0  20# happyReduction_39
+happyReduction_39  =  happyIn29
+                 (Language.Clafer.Front.AbsClafer.SuperEmpty noSpan
+        )
+
+happyReduce_40 = happySpecReduce_2  20# happyReduction_40
+happyReduction_40 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut61 happy_x_2 of { (HappyWrap61 happy_var_2) -> 
+        happyIn29
+                 (Language.Clafer.Front.AbsClafer.SuperSome ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_41 = happySpecReduce_0  21# happyReduction_41
+happyReduction_41  =  happyIn30
+                 (Language.Clafer.Front.AbsClafer.ReferenceEmpty noSpan
+        )
+
+happyReduce_42 = happySpecReduce_2  21# happyReduction_42
+happyReduction_42 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut58 happy_x_2 of { (HappyWrap58 happy_var_2) -> 
+        happyIn30
+                 (Language.Clafer.Front.AbsClafer.ReferenceSet ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_43 = happySpecReduce_2  21# happyReduction_43
+happyReduction_43 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut58 happy_x_2 of { (HappyWrap58 happy_var_2) -> 
+        happyIn30
+                 (Language.Clafer.Front.AbsClafer.ReferenceBag ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_44 = happySpecReduce_0  22# happyReduction_44
+happyReduction_44  =  happyIn31
+                 (Language.Clafer.Front.AbsClafer.InitEmpty noSpan
+        )
+
+happyReduce_45 = happySpecReduce_2  22# happyReduction_45
+happyReduction_45 happy_x_2
+        happy_x_1
+         =  case happyOut32 happy_x_1 of { (HappyWrap32 happy_var_1) -> 
+        case happyOut38 happy_x_2 of { (HappyWrap38 happy_var_2) -> 
+        happyIn31
+                 (Language.Clafer.Front.AbsClafer.InitSome ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_1 happy_var_2
+        )}}
+
+happyReduce_46 = happySpecReduce_1  23# happyReduction_46
+happyReduction_46 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn32
+                 (Language.Clafer.Front.AbsClafer.InitConstant ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_47 = happySpecReduce_1  23# happyReduction_47
+happyReduction_47 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn32
+                 (Language.Clafer.Front.AbsClafer.InitDefault ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_48 = happySpecReduce_0  24# happyReduction_48
+happyReduction_48  =  happyIn33
+                 (Language.Clafer.Front.AbsClafer.GCardEmpty noSpan
+        )
+
+happyReduce_49 = happySpecReduce_1  24# happyReduction_49
+happyReduction_49 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn33
+                 (Language.Clafer.Front.AbsClafer.GCardXor ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_50 = happySpecReduce_1  24# happyReduction_50
+happyReduction_50 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn33
+                 (Language.Clafer.Front.AbsClafer.GCardOr ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_51 = happySpecReduce_1  24# happyReduction_51
+happyReduction_51 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn33
+                 (Language.Clafer.Front.AbsClafer.GCardMux ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_52 = happySpecReduce_1  24# happyReduction_52
+happyReduction_52 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn33
+                 (Language.Clafer.Front.AbsClafer.GCardOpt ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_53 = happySpecReduce_1  24# happyReduction_53
+happyReduction_53 happy_x_1
+         =  case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> 
+        happyIn33
+                 (Language.Clafer.Front.AbsClafer.GCardInterval ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_54 = happySpecReduce_0  25# happyReduction_54
+happyReduction_54  =  happyIn34
+                 (Language.Clafer.Front.AbsClafer.CardEmpty noSpan
+        )
+
+happyReduce_55 = happySpecReduce_1  25# happyReduction_55
+happyReduction_55 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn34
+                 (Language.Clafer.Front.AbsClafer.CardLone ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_56 = happySpecReduce_1  25# happyReduction_56
+happyReduction_56 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn34
+                 (Language.Clafer.Front.AbsClafer.CardSome ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_57 = happySpecReduce_1  25# happyReduction_57
+happyReduction_57 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn34
+                 (Language.Clafer.Front.AbsClafer.CardAny ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_58 = happySpecReduce_1  25# happyReduction_58
+happyReduction_58 happy_x_1
+         =  case happyOut9 happy_x_1 of { (HappyWrap9 happy_var_1) -> 
+        happyIn34
+                 (Language.Clafer.Front.AbsClafer.CardNum ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_59 = happySpecReduce_1  25# happyReduction_59
+happyReduction_59 happy_x_1
+         =  case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> 
+        happyIn34
+                 (Language.Clafer.Front.AbsClafer.CardInterval ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_60 = happySpecReduce_3  26# happyReduction_60
+happyReduction_60 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut9 happy_x_1 of { (HappyWrap9 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut36 happy_x_3 of { (HappyWrap36 happy_var_3) -> 
+        happyIn35
+                 (Language.Clafer.Front.AbsClafer.NCard ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_61 = happySpecReduce_1  27# happyReduction_61
+happyReduction_61 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn36
+                 (Language.Clafer.Front.AbsClafer.ExIntegerAst ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_62 = happySpecReduce_1  27# happyReduction_62
+happyReduction_62 happy_x_1
+         =  case happyOut9 happy_x_1 of { (HappyWrap9 happy_var_1) -> 
+        happyIn36
+                 (Language.Clafer.Front.AbsClafer.ExIntegerNum ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_63 = happySpecReduce_1  28# happyReduction_63
+happyReduction_63 happy_x_1
+         =  case happyOut78 happy_x_1 of { (HappyWrap78 happy_var_1) -> 
+        happyIn37
+                 (Language.Clafer.Front.AbsClafer.Path ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_64 = happySpecReduce_3  29# happyReduction_64
+happyReduction_64 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut39 happy_x_1 of { (HappyWrap39 happy_var_1) -> 
+        case happyOut64 happy_x_2 of { (HappyWrap64 happy_var_2) -> 
+        case happyOut38 happy_x_3 of { (HappyWrap38 happy_var_3) -> 
+        happyIn38
+                 (Language.Clafer.Front.AbsClafer.TransitionExp ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_2 happy_var_3
+        )}}}
+
+happyReduce_65 = happySpecReduce_1  29# happyReduction_65
+happyReduction_65 happy_x_1
+         =  case happyOut39 happy_x_1 of { (HappyWrap39 happy_var_1) -> 
+        happyIn38
+                 (happy_var_1
+        )}
+
+happyReduce_66 = happyReduce 5# 30# happyReduction_66
+happyReduction_66 (happy_x_5 `HappyStk`
+        happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut66 happy_x_3 of { (HappyWrap66 happy_var_3) -> 
+        case happyOutTok happy_x_4 of { happy_var_4 -> 
+        case happyOut39 happy_x_5 of { (HappyWrap39 happy_var_5) -> 
+        happyIn39
+                 (Language.Clafer.Front.AbsClafer.EDeclAllDisj ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4) >- (mkCatSpan happy_var_5)) happy_var_3 happy_var_5
+        ) `HappyStk` happyRest}}}}}
+
+happyReduce_67 = happyReduce 4# 30# happyReduction_67
+happyReduction_67 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut66 happy_x_2 of { (HappyWrap66 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        case happyOut39 happy_x_4 of { (HappyWrap39 happy_var_4) -> 
+        happyIn39
+                 (Language.Clafer.Front.AbsClafer.EDeclAll ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_4
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_68 = happyReduce 5# 30# happyReduction_68
+happyReduction_68 (happy_x_5 `HappyStk`
+        happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOut68 happy_x_1 of { (HappyWrap68 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut66 happy_x_3 of { (HappyWrap66 happy_var_3) -> 
+        case happyOutTok happy_x_4 of { happy_var_4 -> 
+        case happyOut39 happy_x_5 of { (HappyWrap39 happy_var_5) -> 
+        happyIn39
+                 (Language.Clafer.Front.AbsClafer.EDeclQuantDisj ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4) >- (mkCatSpan happy_var_5)) happy_var_1 happy_var_3 happy_var_5
+        ) `HappyStk` happyRest}}}}}
+
+happyReduce_69 = happyReduce 4# 30# happyReduction_69
+happyReduction_69 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOut68 happy_x_1 of { (HappyWrap68 happy_var_1) -> 
+        case happyOut66 happy_x_2 of { (HappyWrap66 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        case happyOut39 happy_x_4 of { (HappyWrap39 happy_var_4) -> 
+        happyIn39
+                 (Language.Clafer.Front.AbsClafer.EDeclQuant ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_1 happy_var_2 happy_var_4
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_70 = happyReduce 6# 30# happyReduction_70
+happyReduction_70 (happy_x_6 `HappyStk`
+        happy_x_5 `HappyStk`
+        happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut39 happy_x_2 of { (HappyWrap39 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        case happyOut39 happy_x_4 of { (HappyWrap39 happy_var_4) -> 
+        case happyOutTok happy_x_5 of { happy_var_5 -> 
+        case happyOut39 happy_x_6 of { (HappyWrap39 happy_var_6) -> 
+        happyIn39
+                 (Language.Clafer.Front.AbsClafer.EImpliesElse ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4) >- (mkTokenSpan happy_var_5) >- (mkCatSpan happy_var_6)) happy_var_2 happy_var_4 happy_var_6
+        ) `HappyStk` happyRest}}}}}}
+
+happyReduce_71 = happyReduce 4# 30# happyReduction_71
+happyReduction_71 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut67 happy_x_2 of { (HappyWrap67 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        case happyOut39 happy_x_4 of { (HappyWrap39 happy_var_4) -> 
+        happyIn39
+                 (Language.Clafer.Front.AbsClafer.LetExp ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_4
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_72 = happySpecReduce_1  30# happyReduction_72
+happyReduction_72 happy_x_1
+         =  case happyOut40 happy_x_1 of { (HappyWrap40 happy_var_1) -> 
+        happyIn39
+                 (happy_var_1
+        )}
+
+happyReduce_73 = happySpecReduce_3  31# happyReduction_73
+happyReduction_73 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> 
+        case happyOut65 happy_x_3 of { (HappyWrap65 happy_var_3) -> 
+        happyIn40
+                 (Language.Clafer.Front.AbsClafer.TmpPatNever ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_2 happy_var_3
+        )}}}
+
+happyReduce_74 = happySpecReduce_3  31# happyReduction_74
+happyReduction_74 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> 
+        case happyOut65 happy_x_3 of { (HappyWrap65 happy_var_3) -> 
+        happyIn40
+                 (Language.Clafer.Front.AbsClafer.TmpPatSometime ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_2 happy_var_3
+        )}}}
+
+happyReduce_75 = happySpecReduce_3  31# happyReduction_75
+happyReduction_75 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> 
+        case happyOut65 happy_x_3 of { (HappyWrap65 happy_var_3) -> 
+        happyIn40
+                 (Language.Clafer.Front.AbsClafer.TmpPatLessOrOnce ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_2 happy_var_3
+        )}}}
+
+happyReduce_76 = happySpecReduce_3  31# happyReduction_76
+happyReduction_76 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> 
+        case happyOut65 happy_x_3 of { (HappyWrap65 happy_var_3) -> 
+        happyIn40
+                 (Language.Clafer.Front.AbsClafer.TmpPatAlways ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_2 happy_var_3
+        )}}}
+
+happyReduce_77 = happyReduce 5# 31# happyReduction_77
+happyReduction_77 (happy_x_5 `HappyStk`
+        happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOut41 happy_x_1 of { (HappyWrap41 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        case happyOut41 happy_x_4 of { (HappyWrap41 happy_var_4) -> 
+        case happyOut65 happy_x_5 of { (HappyWrap65 happy_var_5) -> 
+        happyIn40
+                 (Language.Clafer.Front.AbsClafer.TmpPatPrecede ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4) >- (mkCatSpan happy_var_5)) happy_var_1 happy_var_4 happy_var_5
+        ) `HappyStk` happyRest}}}}}
+
+happyReduce_78 = happyReduce 5# 31# happyReduction_78
+happyReduction_78 (happy_x_5 `HappyStk`
+        happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOut41 happy_x_1 of { (HappyWrap41 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        case happyOut41 happy_x_4 of { (HappyWrap41 happy_var_4) -> 
+        case happyOut65 happy_x_5 of { (HappyWrap65 happy_var_5) -> 
+        happyIn40
+                 (Language.Clafer.Front.AbsClafer.TmpPatFollow ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4) >- (mkCatSpan happy_var_5)) happy_var_1 happy_var_4 happy_var_5
+        ) `HappyStk` happyRest}}}}}
+
+happyReduce_79 = happySpecReduce_2  31# happyReduction_79
+happyReduction_79 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> 
+        happyIn40
+                 (Language.Clafer.Front.AbsClafer.TmpInitially ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_80 = happySpecReduce_2  31# happyReduction_80
+happyReduction_80 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> 
+        happyIn40
+                 (Language.Clafer.Front.AbsClafer.TmpFinally ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_81 = happySpecReduce_1  31# happyReduction_81
+happyReduction_81 happy_x_1
+         =  case happyOut41 happy_x_1 of { (HappyWrap41 happy_var_1) -> 
+        happyIn40
+                 (happy_var_1
+        )}
+
+happyReduce_82 = happySpecReduce_3  32# happyReduction_82
+happyReduction_82 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut41 happy_x_1 of { (HappyWrap41 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> 
+        happyIn41
+                 (Language.Clafer.Front.AbsClafer.EIff ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_83 = happySpecReduce_1  32# happyReduction_83
+happyReduction_83 happy_x_1
+         =  case happyOut42 happy_x_1 of { (HappyWrap42 happy_var_1) -> 
+        happyIn41
+                 (happy_var_1
+        )}
+
+happyReduce_84 = happySpecReduce_3  33# happyReduction_84
+happyReduction_84 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut42 happy_x_1 of { (HappyWrap42 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut43 happy_x_3 of { (HappyWrap43 happy_var_3) -> 
+        happyIn42
+                 (Language.Clafer.Front.AbsClafer.EImplies ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_85 = happySpecReduce_1  33# happyReduction_85
+happyReduction_85 happy_x_1
+         =  case happyOut43 happy_x_1 of { (HappyWrap43 happy_var_1) -> 
+        happyIn42
+                 (happy_var_1
+        )}
+
+happyReduce_86 = happySpecReduce_3  34# happyReduction_86
+happyReduction_86 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut43 happy_x_1 of { (HappyWrap43 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut44 happy_x_3 of { (HappyWrap44 happy_var_3) -> 
+        happyIn43
+                 (Language.Clafer.Front.AbsClafer.EOr ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_87 = happySpecReduce_1  34# happyReduction_87
+happyReduction_87 happy_x_1
+         =  case happyOut44 happy_x_1 of { (HappyWrap44 happy_var_1) -> 
+        happyIn43
+                 (happy_var_1
+        )}
+
+happyReduce_88 = happySpecReduce_3  35# happyReduction_88
+happyReduction_88 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut44 happy_x_1 of { (HappyWrap44 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut45 happy_x_3 of { (HappyWrap45 happy_var_3) -> 
+        happyIn44
+                 (Language.Clafer.Front.AbsClafer.EXor ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_89 = happySpecReduce_1  35# happyReduction_89
+happyReduction_89 happy_x_1
+         =  case happyOut45 happy_x_1 of { (HappyWrap45 happy_var_1) -> 
+        happyIn44
+                 (happy_var_1
+        )}
+
+happyReduce_90 = happySpecReduce_3  36# happyReduction_90
+happyReduction_90 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut45 happy_x_1 of { (HappyWrap45 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut46 happy_x_3 of { (HappyWrap46 happy_var_3) -> 
+        happyIn45
+                 (Language.Clafer.Front.AbsClafer.EAnd ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_91 = happySpecReduce_1  36# happyReduction_91
+happyReduction_91 happy_x_1
+         =  case happyOut46 happy_x_1 of { (HappyWrap46 happy_var_1) -> 
+        happyIn45
+                 (happy_var_1
+        )}
+
+happyReduce_92 = happySpecReduce_3  37# happyReduction_92
+happyReduction_92 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut46 happy_x_1 of { (HappyWrap46 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut47 happy_x_3 of { (HappyWrap47 happy_var_3) -> 
+        happyIn46
+                 (Language.Clafer.Front.AbsClafer.LtlU ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_93 = happySpecReduce_3  37# happyReduction_93
+happyReduction_93 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut46 happy_x_1 of { (HappyWrap46 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut47 happy_x_3 of { (HappyWrap47 happy_var_3) -> 
+        happyIn46
+                 (Language.Clafer.Front.AbsClafer.TmpUntil ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_94 = happySpecReduce_1  37# happyReduction_94
+happyReduction_94 happy_x_1
+         =  case happyOut47 happy_x_1 of { (HappyWrap47 happy_var_1) -> 
+        happyIn46
+                 (happy_var_1
+        )}
+
+happyReduce_95 = happySpecReduce_3  38# happyReduction_95
+happyReduction_95 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut47 happy_x_1 of { (HappyWrap47 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut48 happy_x_3 of { (HappyWrap48 happy_var_3) -> 
+        happyIn47
+                 (Language.Clafer.Front.AbsClafer.LtlW ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_96 = happySpecReduce_3  38# happyReduction_96
+happyReduction_96 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut47 happy_x_1 of { (HappyWrap47 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut48 happy_x_3 of { (HappyWrap48 happy_var_3) -> 
+        happyIn47
+                 (Language.Clafer.Front.AbsClafer.TmpWUntil ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_97 = happySpecReduce_1  38# happyReduction_97
+happyReduction_97 happy_x_1
+         =  case happyOut48 happy_x_1 of { (HappyWrap48 happy_var_1) -> 
+        happyIn47
+                 (happy_var_1
+        )}
+
+happyReduce_98 = happySpecReduce_2  39# happyReduction_98
+happyReduction_98 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut48 happy_x_2 of { (HappyWrap48 happy_var_2) -> 
+        happyIn48
+                 (Language.Clafer.Front.AbsClafer.LtlF ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_99 = happySpecReduce_2  39# happyReduction_99
+happyReduction_99 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut48 happy_x_2 of { (HappyWrap48 happy_var_2) -> 
+        happyIn48
+                 (Language.Clafer.Front.AbsClafer.TmpEventually ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_100 = happySpecReduce_2  39# happyReduction_100
+happyReduction_100 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut48 happy_x_2 of { (HappyWrap48 happy_var_2) -> 
+        happyIn48
+                 (Language.Clafer.Front.AbsClafer.LtlG ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_101 = happySpecReduce_2  39# happyReduction_101
+happyReduction_101 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut48 happy_x_2 of { (HappyWrap48 happy_var_2) -> 
+        happyIn48
+                 (Language.Clafer.Front.AbsClafer.TmpGlobally ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_102 = happySpecReduce_2  39# happyReduction_102
+happyReduction_102 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut48 happy_x_2 of { (HappyWrap48 happy_var_2) -> 
+        happyIn48
+                 (Language.Clafer.Front.AbsClafer.LtlX ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_103 = happySpecReduce_2  39# happyReduction_103
+happyReduction_103 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut48 happy_x_2 of { (HappyWrap48 happy_var_2) -> 
+        happyIn48
+                 (Language.Clafer.Front.AbsClafer.TmpNext ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_104 = happySpecReduce_1  39# happyReduction_104
+happyReduction_104 happy_x_1
+         =  case happyOut49 happy_x_1 of { (HappyWrap49 happy_var_1) -> 
+        happyIn48
+                 (happy_var_1
+        )}
+
+happyReduce_105 = happySpecReduce_2  40# happyReduction_105
+happyReduction_105 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> 
+        happyIn49
+                 (Language.Clafer.Front.AbsClafer.ENeg ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_106 = happySpecReduce_1  40# happyReduction_106
+happyReduction_106 happy_x_1
+         =  case happyOut79 happy_x_1 of { (HappyWrap79 happy_var_1) -> 
+        happyIn49
+                 (happy_var_1
+        )}
+
+happyReduce_107 = happySpecReduce_3  41# happyReduction_107
+happyReduction_107 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> 
+        happyIn50
+                 (Language.Clafer.Front.AbsClafer.ELt ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_108 = happySpecReduce_3  41# happyReduction_108
+happyReduction_108 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> 
+        happyIn50
+                 (Language.Clafer.Front.AbsClafer.EGt ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_109 = happySpecReduce_3  41# happyReduction_109
+happyReduction_109 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> 
+        happyIn50
+                 (Language.Clafer.Front.AbsClafer.EEq ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_110 = happySpecReduce_3  41# happyReduction_110
+happyReduction_110 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> 
+        happyIn50
+                 (Language.Clafer.Front.AbsClafer.ELte ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_111 = happySpecReduce_3  41# happyReduction_111
+happyReduction_111 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> 
+        happyIn50
+                 (Language.Clafer.Front.AbsClafer.EGte ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_112 = happySpecReduce_3  41# happyReduction_112
+happyReduction_112 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> 
+        happyIn50
+                 (Language.Clafer.Front.AbsClafer.ENeq ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_113 = happySpecReduce_3  41# happyReduction_113
+happyReduction_113 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> 
+        happyIn50
+                 (Language.Clafer.Front.AbsClafer.EIn ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_114 = happyReduce 4# 41# happyReduction_114
+happyReduction_114 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        case happyOut51 happy_x_4 of { (HappyWrap51 happy_var_4) -> 
+        happyIn50
+                 (Language.Clafer.Front.AbsClafer.ENin ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_1 happy_var_4
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_115 = happySpecReduce_1  41# happyReduction_115
+happyReduction_115 happy_x_1
+         =  case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> 
+        happyIn50
+                 (happy_var_1
+        )}
+
+happyReduce_116 = happySpecReduce_2  42# happyReduction_116
+happyReduction_116 happy_x_2
+        happy_x_1
+         =  case happyOut68 happy_x_1 of { (HappyWrap68 happy_var_1) -> 
+        case happyOut55 happy_x_2 of { (HappyWrap55 happy_var_2) -> 
+        happyIn51
+                 (Language.Clafer.Front.AbsClafer.EQuantExp ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_1 happy_var_2
+        )}}
+
+happyReduce_117 = happySpecReduce_1  42# happyReduction_117
+happyReduction_117 happy_x_1
+         =  case happyOut52 happy_x_1 of { (HappyWrap52 happy_var_1) -> 
+        happyIn51
+                 (happy_var_1
+        )}
+
+happyReduce_118 = happySpecReduce_3  43# happyReduction_118
+happyReduction_118 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut52 happy_x_1 of { (HappyWrap52 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut53 happy_x_3 of { (HappyWrap53 happy_var_3) -> 
+        happyIn52
+                 (Language.Clafer.Front.AbsClafer.EAdd ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_119 = happySpecReduce_3  43# happyReduction_119
+happyReduction_119 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut52 happy_x_1 of { (HappyWrap52 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut53 happy_x_3 of { (HappyWrap53 happy_var_3) -> 
+        happyIn52
+                 (Language.Clafer.Front.AbsClafer.ESub ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_120 = happySpecReduce_1  43# happyReduction_120
+happyReduction_120 happy_x_1
+         =  case happyOut53 happy_x_1 of { (HappyWrap53 happy_var_1) -> 
+        happyIn52
+                 (happy_var_1
+        )}
+
+happyReduce_121 = happySpecReduce_3  44# happyReduction_121
+happyReduction_121 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut53 happy_x_1 of { (HappyWrap53 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut54 happy_x_3 of { (HappyWrap54 happy_var_3) -> 
+        happyIn53
+                 (Language.Clafer.Front.AbsClafer.EMul ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_122 = happySpecReduce_3  44# happyReduction_122
+happyReduction_122 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut53 happy_x_1 of { (HappyWrap53 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut54 happy_x_3 of { (HappyWrap54 happy_var_3) -> 
+        happyIn53
+                 (Language.Clafer.Front.AbsClafer.EDiv ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_123 = happySpecReduce_3  44# happyReduction_123
+happyReduction_123 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut53 happy_x_1 of { (HappyWrap53 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut54 happy_x_3 of { (HappyWrap54 happy_var_3) -> 
+        happyIn53
+                 (Language.Clafer.Front.AbsClafer.ERem ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_124 = happySpecReduce_1  44# happyReduction_124
+happyReduction_124 happy_x_1
+         =  case happyOut54 happy_x_1 of { (HappyWrap54 happy_var_1) -> 
+        happyIn53
+                 (happy_var_1
+        )}
+
+happyReduce_125 = happySpecReduce_2  45# happyReduction_125
+happyReduction_125 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut55 happy_x_2 of { (HappyWrap55 happy_var_2) -> 
+        happyIn54
+                 (Language.Clafer.Front.AbsClafer.EGMax ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_126 = happySpecReduce_2  45# happyReduction_126
+happyReduction_126 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut55 happy_x_2 of { (HappyWrap55 happy_var_2) -> 
+        happyIn54
+                 (Language.Clafer.Front.AbsClafer.EGMin ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_127 = happySpecReduce_1  45# happyReduction_127
+happyReduction_127 happy_x_1
+         =  case happyOut55 happy_x_1 of { (HappyWrap55 happy_var_1) -> 
+        happyIn54
+                 (happy_var_1
+        )}
+
+happyReduce_128 = happySpecReduce_2  46# happyReduction_128
+happyReduction_128 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut56 happy_x_2 of { (HappyWrap56 happy_var_2) -> 
+        happyIn55
+                 (Language.Clafer.Front.AbsClafer.ESum ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_129 = happySpecReduce_2  46# happyReduction_129
+happyReduction_129 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut56 happy_x_2 of { (HappyWrap56 happy_var_2) -> 
+        happyIn55
+                 (Language.Clafer.Front.AbsClafer.EProd ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_130 = happySpecReduce_2  46# happyReduction_130
+happyReduction_130 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut56 happy_x_2 of { (HappyWrap56 happy_var_2) -> 
+        happyIn55
+                 (Language.Clafer.Front.AbsClafer.ECard ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_131 = happySpecReduce_2  46# happyReduction_131
+happyReduction_131 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut56 happy_x_2 of { (HappyWrap56 happy_var_2) -> 
+        happyIn55
+                 (Language.Clafer.Front.AbsClafer.EMinExp ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_132 = happySpecReduce_1  46# happyReduction_132
+happyReduction_132 happy_x_1
+         =  case happyOut56 happy_x_1 of { (HappyWrap56 happy_var_1) -> 
+        happyIn55
+                 (happy_var_1
+        )}
+
+happyReduce_133 = happySpecReduce_3  47# happyReduction_133
+happyReduction_133 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut56 happy_x_1 of { (HappyWrap56 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut57 happy_x_3 of { (HappyWrap57 happy_var_3) -> 
+        happyIn56
+                 (Language.Clafer.Front.AbsClafer.EDomain ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_134 = happySpecReduce_1  47# happyReduction_134
+happyReduction_134 happy_x_1
+         =  case happyOut57 happy_x_1 of { (HappyWrap57 happy_var_1) -> 
+        happyIn56
+                 (happy_var_1
+        )}
+
+happyReduce_135 = happySpecReduce_3  48# happyReduction_135
+happyReduction_135 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut57 happy_x_1 of { (HappyWrap57 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut58 happy_x_3 of { (HappyWrap58 happy_var_3) -> 
+        happyIn57
+                 (Language.Clafer.Front.AbsClafer.ERange ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_136 = happySpecReduce_1  48# happyReduction_136
+happyReduction_136 happy_x_1
+         =  case happyOut58 happy_x_1 of { (HappyWrap58 happy_var_1) -> 
+        happyIn57
+                 (happy_var_1
+        )}
+
+happyReduce_137 = happySpecReduce_3  49# happyReduction_137
+happyReduction_137 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut58 happy_x_1 of { (HappyWrap58 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut59 happy_x_3 of { (HappyWrap59 happy_var_3) -> 
+        happyIn58
+                 (Language.Clafer.Front.AbsClafer.EUnion ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_138 = happySpecReduce_3  49# happyReduction_138
+happyReduction_138 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut58 happy_x_1 of { (HappyWrap58 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut59 happy_x_3 of { (HappyWrap59 happy_var_3) -> 
+        happyIn58
+                 (Language.Clafer.Front.AbsClafer.EUnionCom ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_139 = happySpecReduce_1  49# happyReduction_139
+happyReduction_139 happy_x_1
+         =  case happyOut59 happy_x_1 of { (HappyWrap59 happy_var_1) -> 
+        happyIn58
+                 (happy_var_1
+        )}
+
+happyReduce_140 = happySpecReduce_3  50# happyReduction_140
+happyReduction_140 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut59 happy_x_1 of { (HappyWrap59 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut60 happy_x_3 of { (HappyWrap60 happy_var_3) -> 
+        happyIn59
+                 (Language.Clafer.Front.AbsClafer.EDifference ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_141 = happySpecReduce_1  50# happyReduction_141
+happyReduction_141 happy_x_1
+         =  case happyOut60 happy_x_1 of { (HappyWrap60 happy_var_1) -> 
+        happyIn59
+                 (happy_var_1
+        )}
+
+happyReduce_142 = happySpecReduce_3  51# happyReduction_142
+happyReduction_142 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut60 happy_x_1 of { (HappyWrap60 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut61 happy_x_3 of { (HappyWrap61 happy_var_3) -> 
+        happyIn60
+                 (Language.Clafer.Front.AbsClafer.EIntersection ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_143 = happySpecReduce_1  51# happyReduction_143
+happyReduction_143 happy_x_1
+         =  case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> 
+        happyIn60
+                 (happy_var_1
+        )}
+
+happyReduce_144 = happySpecReduce_3  52# happyReduction_144
+happyReduction_144 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut62 happy_x_3 of { (HappyWrap62 happy_var_3) -> 
+        happyIn61
+                 (Language.Clafer.Front.AbsClafer.EIntersectionDeprecated ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_145 = happySpecReduce_3  52# happyReduction_145
+happyReduction_145 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut62 happy_x_3 of { (HappyWrap62 happy_var_3) -> 
+        happyIn61
+                 (Language.Clafer.Front.AbsClafer.EJoin ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_146 = happySpecReduce_1  52# happyReduction_146
+happyReduction_146 happy_x_1
+         =  case happyOut62 happy_x_1 of { (HappyWrap62 happy_var_1) -> 
+        happyIn61
+                 (happy_var_1
+        )}
+
+happyReduce_147 = happySpecReduce_1  53# happyReduction_147
+happyReduction_147 happy_x_1
+         =  case happyOut37 happy_x_1 of { (HappyWrap37 happy_var_1) -> 
+        happyIn62
+                 (Language.Clafer.Front.AbsClafer.ClaferId ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_148 = happySpecReduce_1  53# happyReduction_148
+happyReduction_148 happy_x_1
+         =  case happyOut9 happy_x_1 of { (HappyWrap9 happy_var_1) -> 
+        happyIn62
+                 (Language.Clafer.Front.AbsClafer.EInt ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_149 = happySpecReduce_1  53# happyReduction_149
+happyReduction_149 happy_x_1
+         =  case happyOut10 happy_x_1 of { (HappyWrap10 happy_var_1) -> 
+        happyIn62
+                 (Language.Clafer.Front.AbsClafer.EDouble ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_150 = happySpecReduce_1  53# happyReduction_150
+happyReduction_150 happy_x_1
+         =  case happyOut11 happy_x_1 of { (HappyWrap11 happy_var_1) -> 
+        happyIn62
+                 (Language.Clafer.Front.AbsClafer.EReal ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_151 = happySpecReduce_1  53# happyReduction_151
+happyReduction_151 happy_x_1
+         =  case happyOut12 happy_x_1 of { (HappyWrap12 happy_var_1) -> 
+        happyIn62
+                 (Language.Clafer.Front.AbsClafer.EStr ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_152 = happySpecReduce_3  53# happyReduction_152
+happyReduction_152 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut38 happy_x_2 of { (HappyWrap38 happy_var_2) -> 
+        happyIn62
+                 (happy_var_2
+        )}
+
+happyReduce_153 = happySpecReduce_1  54# happyReduction_153
+happyReduction_153 happy_x_1
+         =  case happyOut39 happy_x_1 of { (HappyWrap39 happy_var_1) -> 
+        happyIn63
+                 (Language.Clafer.Front.AbsClafer.TransGuard ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_154 = happySpecReduce_1  55# happyReduction_154
+happyReduction_154 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn64
+                 (Language.Clafer.Front.AbsClafer.SyncTransArrow ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_155 = happySpecReduce_3  55# happyReduction_155
+happyReduction_155 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut63 happy_x_2 of { (HappyWrap63 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        happyIn64
+                 (Language.Clafer.Front.AbsClafer.GuardedSyncTransArrow ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3)) happy_var_2
+        )}}}
+
+happyReduce_156 = happySpecReduce_1  55# happyReduction_156
+happyReduction_156 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn64
+                 (Language.Clafer.Front.AbsClafer.NextTransArrow ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_157 = happySpecReduce_3  55# happyReduction_157
+happyReduction_157 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut63 happy_x_2 of { (HappyWrap63 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        happyIn64
+                 (Language.Clafer.Front.AbsClafer.GuardedNextTransArrow ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3)) happy_var_2
+        )}}}
+
+happyReduce_158 = happySpecReduce_2  56# happyReduction_158
+happyReduction_158 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> 
+        happyIn65
+                 (Language.Clafer.Front.AbsClafer.PatScopeBefore ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_159 = happySpecReduce_2  56# happyReduction_159
+happyReduction_159 happy_x_2
+        happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> 
+        happyIn65
+                 (Language.Clafer.Front.AbsClafer.PatScopeAfter ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+        )}}
+
+happyReduce_160 = happyReduce 4# 56# happyReduction_160
+happyReduction_160 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        case happyOut49 happy_x_4 of { (HappyWrap49 happy_var_4) -> 
+        happyIn65
+                 (Language.Clafer.Front.AbsClafer.PatScopeBetweenAnd ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_4
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_161 = happyReduce 4# 56# happyReduction_161
+happyReduction_161 (happy_x_4 `HappyStk`
+        happy_x_3 `HappyStk`
+        happy_x_2 `HappyStk`
+        happy_x_1 `HappyStk`
+        happyRest)
+         = case happyOutTok happy_x_1 of { happy_var_1 -> 
+        case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> 
+        case happyOutTok happy_x_3 of { happy_var_3 -> 
+        case happyOut49 happy_x_4 of { (HappyWrap49 happy_var_4) -> 
+        happyIn65
+                 (Language.Clafer.Front.AbsClafer.PatScopeAfterUntil ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_4
+        ) `HappyStk` happyRest}}}}
+
+happyReduce_162 = happySpecReduce_0  56# happyReduction_162
+happyReduction_162  =  happyIn65
+                 (Language.Clafer.Front.AbsClafer.PatScopeEmpty noSpan
+        )
+
+happyReduce_163 = happySpecReduce_3  57# happyReduction_163
+happyReduction_163 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut77 happy_x_1 of { (HappyWrap77 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut56 happy_x_3 of { (HappyWrap56 happy_var_3) -> 
+        happyIn66
+                 (Language.Clafer.Front.AbsClafer.Decl ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_164 = happySpecReduce_3  58# happyReduction_164
+happyReduction_164 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut71 happy_x_1 of { (HappyWrap71 happy_var_1) -> 
+        case happyOutTok happy_x_2 of { happy_var_2 -> 
+        case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> 
+        happyIn67
+                 (Language.Clafer.Front.AbsClafer.VarBinding ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+        )}}}
+
+happyReduce_165 = happySpecReduce_1  59# happyReduction_165
+happyReduction_165 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn68
+                 (Language.Clafer.Front.AbsClafer.QuantNo ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_166 = happySpecReduce_1  59# happyReduction_166
+happyReduction_166 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn68
+                 (Language.Clafer.Front.AbsClafer.QuantNot ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_167 = happySpecReduce_1  59# happyReduction_167
+happyReduction_167 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn68
+                 (Language.Clafer.Front.AbsClafer.QuantLone ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_168 = happySpecReduce_1  59# happyReduction_168
+happyReduction_168 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn68
+                 (Language.Clafer.Front.AbsClafer.QuantOne ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_169 = happySpecReduce_1  59# happyReduction_169
+happyReduction_169 happy_x_1
+         =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+        happyIn68
+                 (Language.Clafer.Front.AbsClafer.QuantSome ((mkTokenSpan happy_var_1))
+        )}
+
+happyReduce_170 = happySpecReduce_1  60# happyReduction_170
+happyReduction_170 happy_x_1
+         =  case happyOut13 happy_x_1 of { (HappyWrap13 happy_var_1) -> 
+        happyIn69
+                 (Language.Clafer.Front.AbsClafer.EnumIdIdent ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_171 = happySpecReduce_1  61# happyReduction_171
+happyReduction_171 happy_x_1
+         =  case happyOut13 happy_x_1 of { (HappyWrap13 happy_var_1) -> 
+        happyIn70
+                 (Language.Clafer.Front.AbsClafer.ModIdIdent ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_172 = happySpecReduce_1  62# happyReduction_172
+happyReduction_172 happy_x_1
+         =  case happyOut13 happy_x_1 of { (HappyWrap13 happy_var_1) -> 
+        happyIn71
+                 (Language.Clafer.Front.AbsClafer.LocIdIdent ((mkCatSpan happy_var_1)) happy_var_1
+        )}
+
+happyReduce_173 = happySpecReduce_0  63# happyReduction_173
+happyReduction_173  =  happyIn72
+                 ([]
+        )
+
+happyReduce_174 = happySpecReduce_2  63# happyReduction_174
+happyReduction_174 happy_x_2
+        happy_x_1
+         =  case happyOut72 happy_x_1 of { (HappyWrap72 happy_var_1) -> 
+        case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> 
+        happyIn72
+                 (flip (:)  happy_var_1 happy_var_2
+        )}}
+
+happyReduce_175 = happySpecReduce_2  63# happyReduction_175
+happyReduction_175 happy_x_2
+        happy_x_1
+         =  case happyOut72 happy_x_1 of { (HappyWrap72 happy_var_1) -> 
+        happyIn72
+                 (happy_var_1
+        )}
+
+happyReduce_176 = happySpecReduce_1  64# happyReduction_176
+happyReduction_176 happy_x_1
+         =  case happyOut69 happy_x_1 of { (HappyWrap69 happy_var_1) -> 
+        happyIn73
+                 ((:[])  happy_var_1
+        )}
+
+happyReduce_177 = happySpecReduce_3  64# happyReduction_177
+happyReduction_177 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut69 happy_x_1 of { (HappyWrap69 happy_var_1) -> 
+        case happyOut73 happy_x_3 of { (HappyWrap73 happy_var_3) -> 
+        happyIn73
+                 ((:)  happy_var_1 happy_var_3
+        )}}
+
+happyReduce_178 = happySpecReduce_0  65# happyReduction_178
+happyReduction_178  =  happyIn74
+                 ([]
+        )
+
+happyReduce_179 = happySpecReduce_2  65# happyReduction_179
+happyReduction_179 happy_x_2
+        happy_x_1
+         =  case happyOut74 happy_x_1 of { (HappyWrap74 happy_var_1) -> 
+        case happyOut28 happy_x_2 of { (HappyWrap28 happy_var_2) -> 
+        happyIn74
+                 (flip (:)  happy_var_1 happy_var_2
+        )}}
+
+happyReduce_180 = happySpecReduce_2  65# happyReduction_180
+happyReduction_180 happy_x_2
+        happy_x_1
+         =  case happyOut74 happy_x_1 of { (HappyWrap74 happy_var_1) -> 
+        happyIn74
+                 (happy_var_1
+        )}
+
+happyReduce_181 = happySpecReduce_0  66# happyReduction_181
+happyReduction_181  =  happyIn75
+                 ([]
+        )
+
+happyReduce_182 = happySpecReduce_2  66# happyReduction_182
+happyReduction_182 happy_x_2
+        happy_x_1
+         =  case happyOut75 happy_x_1 of { (HappyWrap75 happy_var_1) -> 
+        case happyOut38 happy_x_2 of { (HappyWrap38 happy_var_2) -> 
+        happyIn75
+                 (flip (:)  happy_var_1 happy_var_2
+        )}}
+
+happyReduce_183 = happySpecReduce_0  67# happyReduction_183
+happyReduction_183  =  happyIn76
+                 ([]
+        )
+
+happyReduce_184 = happySpecReduce_2  67# happyReduction_184
+happyReduction_184 happy_x_2
+        happy_x_1
+         =  case happyOut76 happy_x_1 of { (HappyWrap76 happy_var_1) -> 
+        case happyOut24 happy_x_2 of { (HappyWrap24 happy_var_2) -> 
+        happyIn76
+                 (flip (:)  happy_var_1 happy_var_2
+        )}}
+
+happyReduce_185 = happySpecReduce_1  68# happyReduction_185
+happyReduction_185 happy_x_1
+         =  case happyOut71 happy_x_1 of { (HappyWrap71 happy_var_1) -> 
+        happyIn77
+                 ((:[])  happy_var_1
+        )}
+
+happyReduce_186 = happySpecReduce_3  68# happyReduction_186
+happyReduction_186 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut71 happy_x_1 of { (HappyWrap71 happy_var_1) -> 
+        case happyOut77 happy_x_3 of { (HappyWrap77 happy_var_3) -> 
+        happyIn77
+                 ((:)  happy_var_1 happy_var_3
+        )}}
+
+happyReduce_187 = happySpecReduce_1  69# happyReduction_187
+happyReduction_187 happy_x_1
+         =  case happyOut70 happy_x_1 of { (HappyWrap70 happy_var_1) -> 
+        happyIn78
+                 ((:[])  happy_var_1
+        )}
+
+happyReduce_188 = happySpecReduce_3  69# happyReduction_188
+happyReduction_188 happy_x_3
+        happy_x_2
+        happy_x_1
+         =  case happyOut70 happy_x_1 of { (HappyWrap70 happy_var_1) -> 
+        case happyOut78 happy_x_3 of { (HappyWrap78 happy_var_3) -> 
+        happyIn78
+                 ((:)  happy_var_1 happy_var_3
+        )}}
+
+happyReduce_189 = happySpecReduce_1  70# happyReduction_189
+happyReduction_189 happy_x_1
+         =  case happyOut80 happy_x_1 of { (HappyWrap80 happy_var_1) -> 
+        happyIn79
+                 (happy_var_1
+        )}
+
+happyReduce_190 = happySpecReduce_1  71# happyReduction_190
+happyReduction_190 happy_x_1
+         =  case happyOut81 happy_x_1 of { (HappyWrap81 happy_var_1) -> 
+        happyIn80
+                 (happy_var_1
+        )}
+
+happyReduce_191 = happySpecReduce_1  72# happyReduction_191
+happyReduction_191 happy_x_1
+         =  case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> 
+        happyIn81
+                 (happy_var_1
+        )}
+
+happyTerminalToTok term = case term of {
+        PT _ (TS _ 1) -> 2#;
+        PT _ (TS _ 2) -> 3#;
+        PT _ (TS _ 3) -> 4#;
+        PT _ (TS _ 4) -> 5#;
+        PT _ (TS _ 5) -> 6#;
+        PT _ (TS _ 6) -> 7#;
+        PT _ (TS _ 7) -> 8#;
+        PT _ (TS _ 8) -> 9#;
+        PT _ (TS _ 9) -> 10#;
+        PT _ (TS _ 10) -> 11#;
+        PT _ (TS _ 11) -> 12#;
+        PT _ (TS _ 12) -> 13#;
+        PT _ (TS _ 13) -> 14#;
+        PT _ (TS _ 14) -> 15#;
+        PT _ (TS _ 15) -> 16#;
+        PT _ (TS _ 16) -> 17#;
+        PT _ (TS _ 17) -> 18#;
+        PT _ (TS _ 18) -> 19#;
+        PT _ (TS _ 19) -> 20#;
+        PT _ (TS _ 20) -> 21#;
+        PT _ (TS _ 21) -> 22#;
+        PT _ (TS _ 22) -> 23#;
+        PT _ (TS _ 23) -> 24#;
+        PT _ (TS _ 24) -> 25#;
+        PT _ (TS _ 25) -> 26#;
+        PT _ (TS _ 26) -> 27#;
+        PT _ (TS _ 27) -> 28#;
+        PT _ (TS _ 101) -> 29#;
+        PT _ (TS _ 28) -> 30#;
+        PT _ (TS _ 29) -> 31#;
+        PT _ (TS _ 30) -> 32#;
+        PT _ (TS _ 31) -> 33#;
+        PT _ (TS _ 32) -> 34#;
+        PT _ (TS _ 33) -> 35#;
+        PT _ (TS _ 34) -> 36#;
+        PT _ (TS _ 35) -> 37#;
+        PT _ (TS _ 36) -> 38#;
+        PT _ (TS _ 37) -> 39#;
+        PT _ (TS _ 38) -> 40#;
+        PT _ (TS _ 39) -> 41#;
+        PT _ (TS _ 40) -> 42#;
+        PT _ (TS _ 41) -> 43#;
+        PT _ (TS _ 42) -> 44#;
+        PT _ (TS _ 43) -> 45#;
+        PT _ (TS _ 44) -> 46#;
+        PT _ (TS _ 45) -> 47#;
+        PT _ (TS _ 46) -> 48#;
+        PT _ (TS _ 47) -> 49#;
+        PT _ (TS _ 48) -> 50#;
+        PT _ (TS _ 49) -> 51#;
+        PT _ (TS _ 50) -> 52#;
+        PT _ (TS _ 51) -> 53#;
+        PT _ (TS _ 52) -> 54#;
+        PT _ (TS _ 53) -> 55#;
+        PT _ (TS _ 54) -> 56#;
+        PT _ (TS _ 55) -> 57#;
+        PT _ (TS _ 56) -> 58#;
+        PT _ (TS _ 57) -> 59#;
+        PT _ (TS _ 58) -> 60#;
+        PT _ (TS _ 59) -> 61#;
+        PT _ (TS _ 60) -> 62#;
+        PT _ (TS _ 61) -> 63#;
+        PT _ (TS _ 62) -> 64#;
+        PT _ (TS _ 63) -> 65#;
+        PT _ (TS _ 64) -> 66#;
+        PT _ (TS _ 65) -> 67#;
+        PT _ (TS _ 66) -> 68#;
+        PT _ (TS _ 67) -> 69#;
+        PT _ (TS _ 68) -> 70#;
+        PT _ (TS _ 69) -> 71#;
+        PT _ (TS _ 70) -> 72#;
+        PT _ (TS _ 71) -> 73#;
+        PT _ (TS _ 72) -> 74#;
+        PT _ (TS _ 73) -> 75#;
+        PT _ (TS _ 74) -> 76#;
+        PT _ (TS _ 75) -> 77#;
+        PT _ (TS _ 76) -> 78#;
+        PT _ (TS _ 77) -> 79#;
+        PT _ (TS _ 78) -> 80#;
+        PT _ (TS _ 79) -> 81#;
+        PT _ (TS _ 80) -> 82#;
+        PT _ (TS _ 81) -> 83#;
+        PT _ (TS _ 82) -> 84#;
+        PT _ (TS _ 83) -> 85#;
+        PT _ (TS _ 84) -> 86#;
+        PT _ (TS _ 85) -> 87#;
+        PT _ (TS _ 86) -> 88#;
+        PT _ (TS _ 87) -> 89#;
+        PT _ (TS _ 88) -> 90#;
+        PT _ (TS _ 89) -> 91#;
+        PT _ (TS _ 90) -> 92#;
+        PT _ (TS _ 91) -> 93#;
+        PT _ (TS _ 92) -> 94#;
+        PT _ (TS _ 93) -> 95#;
+        PT _ (TS _ 94) -> 96#;
+        PT _ (TS _ 95) -> 97#;
+        PT _ (TS _ 96) -> 98#;
+        PT _ (TS _ 97) -> 99#;
+        PT _ (TS _ 98) -> 100#;
+        PT _ (TS _ 99) -> 101#;
+        PT _ (TS _ 100) -> 102#;
+        PT _ (T_PosInteger _) -> 103#;
+        PT _ (T_PosDouble _) -> 104#;
+        PT _ (T_PosReal _) -> 105#;
+        PT _ (T_PosString _) -> 106#;
+        PT _ (T_PosIdent _) -> 107#;
+        PT _ (T_PosLineComment _) -> 108#;
+        PT _ (T_PosBlockComment _) -> 109#;
+        PT _ (T_PosAlloy _) -> 110#;
+        PT _ (T_PosChoco _) -> 111#;
+        _ -> -1#;
+        }
+{-# NOINLINE happyTerminalToTok #-}
+
+happyLex kend  _kmore []       = kend notHappyAtAll []
+happyLex _kend kmore  (tk:tks) = kmore (happyTerminalToTok tk) tk tks
+{-# INLINE happyLex #-}
+
+happyNewToken action sts stk = happyLex (\tk -> happyDoAction 112# notHappyAtAll action sts stk) (\i tk -> happyDoAction i tk action sts stk)
+
+happyReport 112# tk explist resume tks = happyReport' tks explist resume
+happyReport _ tk explist resume tks = happyReport' (tk:tks) explist (\tks -> resume (Happy_Prelude.tail tks))
+
+
+happyThen :: () => (Err a) -> (a -> (Err b)) -> (Err b)
+happyThen = (thenM)
+happyReturn :: () => a -> (Err a)
+happyReturn = (returnM)
+happyThen1 m k tks = (thenM) m (\a -> k a tks)
+happyFmap1 f m tks = happyThen (m tks) (\a -> happyReturn (f a))
+happyReturn1 :: () => a -> b -> (Err a)
+happyReturn1 = \a tks -> (returnM) a
+happyReport' :: () => [(Token)] -> [Happy_Prelude.String] -> ([(Token)] -> (Err a)) -> (Err a)
+happyReport' = (\tokens expected resume -> happyError tokens)
+
+happyAbort :: () => [(Token)] -> (Err a)
+happyAbort = Happy_Prelude.error "Called abort handler in non-resumptive parser"
+
+pModule tks = happySomeParser where
+ happySomeParser = happyThen (happyDoParse 0# tks) (\x -> happyReturn (let {(HappyWrap18 x') = happyOut18 x} in x'))
+
+pClafer tks = happySomeParser where
+ happySomeParser = happyThen (happyDoParse 1# tks) (\x -> happyReturn (let {(HappyWrap20 x') = happyOut20 x} in x'))
+
+pConstraint tks = happySomeParser where
+ happySomeParser = happyThen (happyDoParse 2# tks) (\x -> happyReturn (let {(HappyWrap21 x') = happyOut21 x} in x'))
+
+pAssertion tks = happySomeParser where
+ happySomeParser = happyThen (happyDoParse 3# tks) (\x -> happyReturn (let {(HappyWrap22 x') = happyOut22 x} in x'))
+
+pGoal tks = happySomeParser where
+ happySomeParser = happyThen (happyDoParse 4# tks) (\x -> happyReturn (let {(HappyWrap23 x') = happyOut23 x} in x'))
+
+happySeq = happyDontSeq
+
+
+returnM :: a -> Err a
+returnM = return
+
+thenM :: Err a -> (a -> Err b) -> Err b
+thenM = (>>=)
+
+happyError :: [Token] -> Err a
+-- | The separator of sibling lines, which the layout resolver inserts, e.g., in @a ; 2..3 b@,
+--   so that a group cardinality at the start of a line is not the cardinality of the clafer on
+--   the line before. It is not a reserved symbol, so a model cannot contain it.
+layoutSeparator :: Token
+layoutSeparator = PT (Pn 0 0 0) (TS "" 101)
+
+isLayoutSeparator :: Token -> Bool
+isLayoutSeparator (PT _ (TS _ 101)) = True
+isLayoutSeparator _ = False
+
+happyError ts' =
+  -- the position is reported with the error; in a model of several files, the line of the
+  -- token is a line of the complete model. The separators inserted by the layout resolver
+  -- are not shown.
+  let ts = filter (not . isLayoutSeparator) ts' in
+  Bad (pp ts) $ "syntax error" ++
+  case ts of
+    [] -> " at end of file"
+    [Err _] -> " due to lexer error"
+    _ -> " before " ++ unwords (map (id . prToken) (take 4 ts))
+
+myLexer = tokens
+
+gp x@(PT (Pn _ l c) _) = Span (Pos (toInteger l) (toInteger c)) (Pos (toInteger l) (toInteger c + toInteger (length $ prToken x)))
+pp (PT (Pn _ l c) _ :_) = Pos (toInteger l) (toInteger c)
+pp (Err (Pn _ l c) :_) = Pos (toInteger l) (toInteger c)
+pp _ = error "EOF"
+
+mkCatSpan :: (Spannable c) => c -> Span
+mkCatSpan = getSpan
+
+mkTokenSpan :: Token -> Span
+mkTokenSpan = gp
+#define HAPPY_COERCE 1
+-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $
+
+#if !defined(__GLASGOW_HASKELL__)
+#  error This code isn't being built with GHC.
+#endif
+
+-- Get WORDS_BIGENDIAN (if defined)
+#include "MachDeps.h"
+
+-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
+#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Happy_Prelude.Bool)
+#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Happy_Prelude.Bool)
+#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Happy_Prelude.Bool)
+#define PLUS(n,m) (n Happy_GHC_Exts.+# m)
+#define MINUS(n,m) (n Happy_GHC_Exts.-# m)
+#define TIMES(n,m) (n Happy_GHC_Exts.*# m)
+#define NEGATE(n) (Happy_GHC_Exts.negateInt# (n))
+
+type Happy_Int = Happy_GHC_Exts.Int#
+data Happy_IntList = HappyCons Happy_Int Happy_IntList
+
+#define INVALID_TOK -1#
+#define ERROR_TOK 0#
+#define CATCH_TOK 1#
+
+#if defined(HAPPY_COERCE)
+#  define GET_ERROR_TOKEN(x)  (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# i) -> i })
+#  define MK_ERROR_TOKEN(i)   (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# i))
+#  define MK_TOKEN(x)         (happyInTok (x))
+#else
+#  define GET_ERROR_TOKEN(x)  (case x of { HappyErrorToken (Happy_GHC_Exts.I# i) -> i })
+#  define MK_ERROR_TOKEN(i)   (HappyErrorToken (Happy_GHC_Exts.I# i))
+#  define MK_TOKEN(x)         (HappyTerminal (x))
+#endif
+
+#if defined(HAPPY_DEBUG)
+#  define DEBUG_TRACE(s)    (happyTrace (s)) Happy_Prelude.$
+happyTrace string expr = Happy_System_IO_Unsafe.unsafePerformIO Happy_Prelude.$ do
+    Happy_System_IO.hPutStr Happy_System_IO.stderr string
+    Happy_Prelude.return expr
+#else
+#  define DEBUG_TRACE(s)    {- nothing -}
+#endif
+
+infixr 9 `HappyStk`
+data HappyStk a = HappyStk a (HappyStk a)
+
+-----------------------------------------------------------------------------
+-- starting the parse
+
+happyDoParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll
+
+-----------------------------------------------------------------------------
+-- Accepting the parse
+
+-- If the current token is ERROR_TOK, it means we've just accepted a partial
+-- parse (a %partial parser).  We must ignore the saved token on the top of
+-- the stack in this case.
+happyAccept ERROR_TOK tk st sts (_ `HappyStk` ans `HappyStk` _) =
+        happyReturn1 ans
+happyAccept j tk st sts (HappyStk ans _) =
+        (happyTcHack j (happyTcHack st)) (happyReturn1 ans)
+
+-----------------------------------------------------------------------------
+-- Arrays only: do the next action
+
+happyDoAction i tk st =
+  DEBUG_TRACE("state: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++
+              ",\ttoken: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++
+              ",\taction: ")
+  case happyDecodeAction (happyNextAction i st) of
+    HappyFail             -> DEBUG_TRACE("failing.\n")
+                             happyFail i tk st
+    HappyAccept           -> DEBUG_TRACE("accept.\n")
+                             happyAccept i tk st
+    HappyReduce rule      -> DEBUG_TRACE("reduce (rule " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# rule) Happy_Prelude.++ ")")
+                             (happyReduceArr Happy_Data_Array.! (Happy_GHC_Exts.I# rule)) i tk st
+    HappyShift  new_state -> DEBUG_TRACE("shift, enter state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
+                             happyShift new_state i tk st
+
+{-# INLINE happyNextAction #-}
+happyNextAction i st = case happyIndexActionTable i st of
+  Happy_Prelude.Just (Happy_GHC_Exts.I# act) -> act
+  Happy_Prelude.Nothing                      -> happyIndexOffAddr happyDefActions st
+
+{-# INLINE happyIndexActionTable #-}
+happyIndexActionTable i st
+  | GTE(i, 0#), GTE(off, 0#), EQ(happyIndexOffAddr happyCheck off, i)
+  -- i >= 0:   Guard against INVALID_TOK (do the default action, which ultimately errors)
+  -- off >= 0: Otherwise it's a default action
+  -- equality check: Ensure that the entry in the compressed array is owned by st
+  = Happy_Prelude.Just (Happy_GHC_Exts.I# (happyIndexOffAddr happyTable off))
+  | Happy_Prelude.otherwise
+  = Happy_Prelude.Nothing
+  where
+    off = PLUS(happyIndexOffAddr happyActOffsets st, i)
+
+data HappyAction
+  = HappyFail
+  | HappyAccept
+  | HappyReduce Happy_Int -- rule number
+  | HappyShift Happy_Int  -- new state
+  deriving Happy_Prelude.Show
+
+{-# INLINE happyDecodeAction #-}
+happyDecodeAction :: Happy_Int -> HappyAction
+happyDecodeAction  0#                        = HappyFail
+happyDecodeAction -1#                        = HappyAccept
+happyDecodeAction action | LT(action, 0#)    = HappyReduce NEGATE(PLUS(action, 1#))
+                         | Happy_Prelude.otherwise = HappyShift MINUS(action, 1#)
+
+{-# INLINE happyIndexGotoTable #-}
+happyIndexGotoTable nt st = happyIndexOffAddr happyTable off
+  where
+    off = PLUS(happyIndexOffAddr happyGotoOffsets st, nt)
+
+{-# INLINE happyIndexOffAddr #-}
+happyIndexOffAddr :: HappyAddr -> Happy_Int -> Happy_Int
+happyIndexOffAddr (HappyA# arr) off =
+#if __GLASGOW_HASKELL__ >= 901
+  Happy_GHC_Exts.int32ToInt# -- qualified import because it doesn't exist on older GHC's
+#endif
+#ifdef WORDS_BIGENDIAN
+  -- The CI of `alex` tests this code path
+  (Happy_GHC_Exts.word32ToInt32# (Happy_GHC_Exts.wordToWord32# (Happy_GHC_Exts.byteSwap32# (Happy_GHC_Exts.word32ToWord# (Happy_GHC_Exts.int32ToWord32#
+#endif
+  (Happy_GHC_Exts.indexInt32OffAddr# arr off)
+#ifdef WORDS_BIGENDIAN
+  )))))
+#endif
+
+happyIndexRuleArr :: Happy_Int -> (# Happy_Int, Happy_Int #)
+happyIndexRuleArr r = (# nt, len #)
+  where
+    !(Happy_GHC_Exts.I# n_starts) = happy_n_starts
+    offs = TIMES(MINUS(r,n_starts),2#)
+    nt = happyIndexOffAddr happyRuleArr offs
+    len = happyIndexOffAddr happyRuleArr PLUS(offs,1#)
+
+data HappyAddr = HappyA# Happy_GHC_Exts.Addr#
+
+-----------------------------------------------------------------------------
+-- Shifting a token
+
+happyShift new_state ERROR_TOK tk st sts stk@(x `HappyStk` _) =
+     -- See "Error Fixup" below
+     let i = GET_ERROR_TOKEN(x) in
+     DEBUG_TRACE("shifting the error token")
+     happyDoAction i tk new_state (HappyCons st sts) stk
+
+happyShift new_state i tk st sts stk =
+     happyNewToken new_state (HappyCons st sts) (MK_TOKEN(tk) `HappyStk` stk)
+
+-- happyReduce is specialised for the common cases.
+
+happySpecReduce_0 nt fn j tk st sts stk
+     = happySeq fn (happyGoto nt j tk st (HappyCons st sts) (fn `HappyStk` stk))
+
+happySpecReduce_1 nt fn j tk old_st sts@(HappyCons st _) (v1 `HappyStk` stk')
+     = let r = fn v1 in
+       happyTcHack old_st (happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')))
+
+happySpecReduce_2 nt fn j tk old_st
+  (HappyCons _ sts@(HappyCons st _))
+  (v1 `HappyStk` v2 `HappyStk` stk')
+     = let r = fn v1 v2 in
+       happyTcHack old_st (happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')))
+
+happySpecReduce_3 nt fn j tk old_st
+  (HappyCons _ (HappyCons _ sts@(HappyCons st _)))
+  (v1 `HappyStk` v2 `HappyStk` v3 `HappyStk` stk')
+     = let r = fn v1 v2 v3 in
+       happyTcHack old_st (happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')))
+
+happyReduce k nt fn j tk st sts stk
+     = case happyDrop MINUS(k,(1# :: Happy_Int)) sts of
+         sts1@(HappyCons st1 _) ->
+                let r = fn stk in -- it doesn't hurt to always seq here...
+                st `happyTcHack` happyDoSeq r (happyGoto nt j tk st1 sts1 r)
+
+happyMonadReduce k nt fn j tk st sts stk =
+      case happyDrop k (HappyCons st sts) of
+        sts1@(HappyCons st1 _) ->
+          let drop_stk = happyDropStk k stk in
+          j `happyTcHack` happyThen1 (fn stk tk)
+                                     (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))
+
+happyMonad2Reduce k nt fn j tk st sts stk =
+      case happyDrop k (HappyCons st sts) of
+        sts1@(HappyCons st1 _) ->
+          let drop_stk = happyDropStk k stk
+              off = happyIndexOffAddr happyGotoOffsets st1
+              off_i = PLUS(off, nt)
+              new_state = happyIndexOffAddr happyTable off_i
+          in
+            j `happyTcHack` happyThen1 (fn stk tk)
+                                       (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))
+
+happyDrop 0# l               = l
+happyDrop n  (HappyCons _ t) = happyDrop MINUS(n,(1# :: Happy_Int)) t
+
+happyDropStk 0# l                 = l
+happyDropStk n  (x `HappyStk` xs) = happyDropStk MINUS(n,(1#::Happy_Int)) xs
+
+-----------------------------------------------------------------------------
+-- Moving to a new state after a reduction
+
+happyGoto nt j tk st =
+   DEBUG_TRACE(", goto state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
+   happyDoAction j tk new_state
+  where new_state = happyIndexGotoTable nt st
+
+{- Note [Error recovery]
+~~~~~~~~~~~~~~~~~~~~~~~~
+When there is no applicable action for the current lookahead token `tk`,
+happy enters error recovery mode. Depending on whether the grammar file
+declares the two action form `%error { abort } { report }` for
+    Resumptive Error Handling,
+it works in one (not resumptive) or two phases (resumptive):
+
+ 1. Fixup mode:
+    Try to see if there is an action for the error token ERROR_TOK. If there
+    is, do *not* emit an error and pretend instead that an `error` token was
+    inserted.
+    When there is no ERROR_TOK action, report an error.
+
+    In non-resumptive error handling, calling the single error handler
+    (e.g. `happyError`) will throw an exception and abort the parser.
+    However, in resumptive error handling we enter *error resumption mode*.
+
+ 2. Error resumption mode:
+    After reporting the error (with `report`), happy will attempt to find
+    a good state stack to resume parsing in.
+    For each candidate stack, it discards input until one of the candidates
+    resumes (i.e. shifts the current input).
+    If no candidate resumes before the end of input, resumption failed and
+    calls the `abort` function, to much the same effect as in non-resumptive
+    error handling.
+
+    Candidate stacks are declared by the grammar author using the special
+    `catch` terminal and called "catch frames".
+    This mechanism is described in detail in Note [happyResume].
+
+The `catch` resumption mechanism (2) is what usually is associated with
+`error` in `bison` or `menhir`. Since `error` is used for the Fixup mechanism
+(1) above, we call the corresponding token `catch`.
+Furthermore, in constrast to `bison`, our implementation of `catch`
+non-deterministically considers multiple catch frames on the stack for
+resumption (See Note [Multiple catch frames]).
+
+Note [happyResume]
+~~~~~~~~~~~~~~~~~~
+`happyResume` implements the resumption mechanism from Note [Error recovery].
+It is best understood by example. Consider
+
+Exp :: { String }
+Exp : '1'                { "1" }
+    | catch              { "catch" }
+    | Exp '+' Exp %shift { $1 Happy_Prelude.++ " + " Happy_Prelude.++ $3 } -- %shift: associate 1 + 1 + 1 to the right
+    | '(' Exp ')'        { "(" Happy_Prelude.++ $2 Happy_Prelude.++ ")" }
+
+The idea of the use of `catch` here is that upon encountering a parse error
+during expression parsing, we can gracefully degrade using the `catch` rule,
+still producing a partial syntax tree and keep on parsing to find further
+syntax errors.
+
+Let's trace the parser state for input 11+1, which will error out after shifting 1.
+After shifting, we have the following item stack (growing downwards and omitting
+transitive closure items):
+
+  State 0: %start_parseExp -> . Exp
+  State 5: Exp -> '1' .
+
+(Stack as a list of state numbers: [5,0].)
+As Note [Error recovery] describes, we will first try Fixup mode.
+That fails because no production can shift the `error` token.
+Next we try Error resumption mode. This works as follows:
+
+  1. Pop off the item stack until we find an item that can shift the `catch`
+     token. (Implemented in `pop_items`.)
+       * State 5 cannot shift catch. Pop.
+       * State 0 can shift catch, which would transition into
+          State 4: Exp -> catch .
+     So record the *stack* `[4,0]` after doing the shift transition.
+     We call this a *catch frame*, where the top is a *catch state*,
+     corresponding to an item in which we just shifted a `catch` token.
+     There can be multiple such catch stacks, see Note [Multiple catch frames].
+
+  2. Discard tokens from the input until the lookahead can be shifted in one
+     of the catch stacks. (Implemented in `discard_input_until_exp` and
+     `some_catch_state_shifts`.)
+       * We cannot shift the current lookahead '1' in state 4, so we discard
+       * We *can* shift the next lookahead '+' in state 4, but only after
+         reducing, which pops State 4 and goes to State 3:
+           State 3: %start_parseExp -> Exp .
+                    Exp -> Exp . '+' Exp
+         Here we can shift '+'.
+     As you can see, to implement this machinery we need to simulate
+     the operation of the LALR automaton, especially reduction
+     (`happySimulateReduce`).
+
+Note [Multiple catch frames]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+For fewer spurious error messages, it can be beneficial to trace multiple catch
+items. Consider
+
+Exp : '1'
+    | catch
+    | Exp '+' Exp %shift
+    | '(' Exp ')'
+
+Let's trace the parser state for input (;+1, which will error out after shifting (.
+After shifting, we have the following item stack (growing downwards):
+
+  State 0: %start_parseExp -> . Exp
+  State 6: Exp -> '(' . Exp ')'
+
+Upon error, we want to find items in the stack which can shift a catch token.
+Note that both State 0 and State 6 can shift a catch token, transitioning into
+  State 4: Exp -> catch .
+Hence we record the catch frames `[4,6,0]` and `[4,0]` for possible resumption.
+
+Which catch frame do we pick for resumption?
+Note that resuming catch frame `[4,0]` will parse as "catch+1", whereas
+resuming the innermost frame `[4,6,0]` corresponds to parsing "(catch+1".
+The latter would keep discarding input until the closing ')' is found.
+So we will discard + and 1, leading to a spurious syntax error at the end of
+input, aborting the parse and never producing a partial syntax tree. Bad!
+
+It is far preferable to resume with catch frame `[4,0]`, where we can resume
+successfully on input +, so that is what we do.
+
+In general, we pick the catch frame for resumption that discards the least
+amount of input for a successful shift, preferring the topmost such catch frame.
+-}
+
+-- happyFail :: Happy_Int -> Token -> Happy_Int -> _
+-- This function triggers Note [Error recovery].
+-- If the current token is ERROR_TOK, phase (1) has failed and we might try
+-- phase (2).
+happyFail ERROR_TOK = happyFixupFailed
+happyFail i         = happyTryFixup i
+
+-- Enter Error Fixup (see Note [Error recovery]):
+-- generate an error token, save the old token and carry on.
+-- When a `happyShift` accepts the error token, we will pop off the error token
+-- to resume parsing with the current lookahead `i`.
+happyTryFixup i tk action sts stk =
+  DEBUG_TRACE("entering `error` fixup.\n")
+  happyDoAction ERROR_TOK tk action sts (MK_ERROR_TOKEN(i) `HappyStk` stk)
+  -- NB: `happyShift` will simply pop the error token and carry on with
+  --     `tk`. Hence we don't change `tk` in the call here
+
+-- See Note [Error recovery], phase (2).
+-- Enter resumption mode after reporting the error by calling `happyResume`.
+happyFixupFailed tk st sts (x `HappyStk` stk) =
+  let i = GET_ERROR_TOKEN(x) in
+  DEBUG_TRACE("`error` fixup failed.\n")
+  let resume   = happyResume i tk st sts stk
+      expected = happyExpectedTokens st sts in
+  happyReport i tk expected resume
+
+-- happyResume :: Happy_Int -> Token -> Happy_Int -> _
+-- See Note [happyResume]
+happyResume i tk st sts stk = pop_items [] st sts stk
+  where
+    !(Happy_GHC_Exts.I# n_starts) = happy_n_starts   -- this is to test whether we have a start token
+    !(Happy_GHC_Exts.I# eof_i) = happy_n_terms Happy_Prelude.- 1   -- this is the token number of the EOF token
+    happy_list_to_list :: Happy_IntList -> [Happy_Prelude.Int]
+    happy_list_to_list (HappyCons st sts)
+      | LT(st, n_starts)
+      = [(Happy_GHC_Exts.I# st)]
+      | Happy_Prelude.otherwise
+      = (Happy_GHC_Exts.I# st) : happy_list_to_list sts
+
+    -- See (1) of Note [happyResume]
+    pop_items catch_frames st sts stk
+      | LT(st, n_starts)
+      = DEBUG_TRACE("reached start state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", ")
+        if Happy_Prelude.null catch_frames_new
+          then DEBUG_TRACE("no resumption.\n")
+               happyAbort
+          else DEBUG_TRACE("now discard input, trying to anchor in states " Happy_Prelude.++ Happy_Prelude.show (Happy_Prelude.map (happy_list_to_list . Happy_Prelude.fst) (Happy_Prelude.reverse catch_frames_new)) Happy_Prelude.++ ".\n")
+               discard_input_until_exp i tk (Happy_Prelude.reverse catch_frames_new)
+      | (HappyCons st1 sts1) <- sts, _ `HappyStk` stk1 <- stk
+      = pop_items catch_frames_new st1 sts1 stk1
+      where
+        !catch_frames_new
+          | HappyShift new_state <- happyDecodeAction (happyNextAction CATCH_TOK st)
+          , DEBUG_TRACE("can shift catch token in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", into state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
+            Happy_Prelude.null (Happy_Prelude.filter (\(HappyCons _ (HappyCons h _),_) -> EQ(st,h)) catch_frames)
+          = (HappyCons new_state (HappyCons st sts), MK_ERROR_TOKEN(i) `HappyStk` stk):catch_frames -- MK_ERROR_TOKEN(i) is just some dummy that should not be accessed by user code
+          | Happy_Prelude.otherwise
+          = DEBUG_TRACE("already shifted or can't shift catch in " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ "\n")
+            catch_frames
+
+    -- See (2) of Note [happyResume]
+    discard_input_until_exp i tk catch_frames
+      | Happy_Prelude.Just (HappyCons st (HappyCons catch_st sts), catch_frame) <- some_catch_state_shifts i catch_frames
+      = DEBUG_TRACE("found expected token in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ " after shifting from " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# catch_st) Happy_Prelude.++ ": " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ "\n")
+        happyDoAction i tk st (HappyCons catch_st sts) catch_frame
+      | EQ(i,eof_i) -- is i EOF?
+      = DEBUG_TRACE("reached EOF, cannot resume. abort parse :(\n")
+        happyAbort
+      | Happy_Prelude.otherwise
+      = DEBUG_TRACE("discard token " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ "\n")
+        happyLex (\eof_tk -> discard_input_until_exp eof_i eof_tk catch_frames) -- eof
+                 (\i tk   -> discard_input_until_exp i tk catch_frames)         -- not eof
+
+    some_catch_state_shifts _ [] = DEBUG_TRACE("no catch state could shift.\n") Happy_Prelude.Nothing
+    some_catch_state_shifts i catch_frames@(((HappyCons st sts),_):_) = try_head i st sts catch_frames
+      where
+        try_head i st sts catch_frames = -- PRECONDITION: head catch_frames = (HappyCons st sts)
+          DEBUG_TRACE("trying token " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ " in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ": ")
+          case happyDecodeAction (happyNextAction i st) of
+            HappyFail     -> DEBUG_TRACE("fail.\n")   some_catch_state_shifts i (Happy_Prelude.tail catch_frames)
+            HappyAccept   -> DEBUG_TRACE("accept.\n") Happy_Prelude.Just (Happy_Prelude.head catch_frames)
+            HappyShift _  -> DEBUG_TRACE("shift.\n")  Happy_Prelude.Just (Happy_Prelude.head catch_frames)
+            HappyReduce r -> case happySimulateReduce r st sts of
+              (HappyCons st1 sts1) -> try_head i st1 sts1 catch_frames
+
+happySimulateReduce r st sts =
+  DEBUG_TRACE("simulate reduction of rule " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# r) Happy_Prelude.++ ", ")
+  let (# nt, len #) = happyIndexRuleArr r in
+  DEBUG_TRACE("nt " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# nt) Happy_Prelude.++ ", len: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# len) Happy_Prelude.++ ", new_st ")
+  let !(sts1@(HappyCons st1 _)) = happyDrop len (HappyCons st sts)
+      new_st = happyIndexGotoTable nt st1 in
+  DEBUG_TRACE(Happy_Prelude.show (Happy_GHC_Exts.I# new_st) Happy_Prelude.++ ".\n")
+  (HappyCons new_st sts1)
+
+happyTokenToString :: Happy_Prelude.Int -> Happy_Prelude.String
+happyTokenToString i = happyTokenStrings Happy_Prelude.!! (i Happy_Prelude.- 2) -- 2: errorTok, catchTok
+
+happyExpectedTokens :: Happy_Int -> Happy_IntList -> [Happy_Prelude.String]
+-- Upon a parse error, we want to suggest tokens that are expected in that
+-- situation. This function computes such tokens.
+-- It works by examining the top of the state stack.
+-- For every token number that does a shift transition, record that token number.
+-- For every token number that does a reduce transition, simulate that reduction
+-- on the state state stack and repeat.
+-- The recorded token numbers are then formatted with 'happyTokenToString' and
+-- returned.
+happyExpectedTokens st sts =
+  DEBUG_TRACE("constructing expected tokens.\n")
+  Happy_Prelude.map happyTokenToString (search_shifts st sts [])
+  where
+    search_shifts st sts shifts = Happy_Prelude.foldr (add_action st sts) shifts (distinct_actions st)
+    add_action st sts (Happy_GHC_Exts.I# i, Happy_GHC_Exts.I# act) shifts =
+      DEBUG_TRACE("found action in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", input " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ ", " Happy_Prelude.++ Happy_Prelude.show (happyDecodeAction act) Happy_Prelude.++ "\n")
+      case happyDecodeAction act of
+        HappyFail     -> shifts
+        HappyAccept   -> shifts -- This would always be %eof or error... Not helpful
+        HappyShift _  -> Happy_Prelude.insert (Happy_GHC_Exts.I# i) shifts
+        HappyReduce r -> case happySimulateReduce r st sts of
+          (HappyCons st1 sts1) -> search_shifts st1 sts1 shifts
+    distinct_actions st
+      -- The (token number, action) pairs of all actions in the given state
+      = ((-1), (Happy_GHC_Exts.I# (happyIndexOffAddr happyDefActions st)))
+      : [ (i, act) | i <- [begin_i..happy_n_terms], act <- get_act row_off i ]
+      where
+        row_off = happyIndexOffAddr happyActOffsets st
+        begin_i = 2 -- +2: errorTok,catchTok
+    get_act off (Happy_GHC_Exts.I# i) -- happyIndexActionTable with cached row offset
+      | let off_i = PLUS(off,i)
+      , GTE(off_i,0#)
+      , EQ(happyIndexOffAddr happyCheck off_i,i)
+      = [(Happy_GHC_Exts.I# (happyIndexOffAddr happyTable off_i))]
+      | Happy_Prelude.otherwise
+      = []
+
+-- Internal happy errors:
+
+notHappyAtAll :: a
+notHappyAtAll = Happy_Prelude.error "Internal Happy parser panic. This is not supposed to happen! Please open a bug report at https://github.com/haskell/happy/issues.\n"
+
+-----------------------------------------------------------------------------
+-- Hack to get the typechecker to accept our action functions
+
+happyTcHack :: Happy_Int -> a -> a
+happyTcHack x y = y
+{-# INLINE happyTcHack #-}
+
+-----------------------------------------------------------------------------
+-- Seq-ing.  If the --strict flag is given, then Happy emits
+--      happySeq = happyDoSeq
+-- otherwise it emits
+--      happySeq = happyDontSeq
+
+happyDoSeq, happyDontSeq :: a -> b -> b
+happyDoSeq   a b = a `Happy_GHC_Exts.seq` b
+happyDontSeq a b = b
+
+-----------------------------------------------------------------------------
+-- Don't inline any functions from the template.  GHC has a nasty habit
+-- of deciding to inline happyGoto everywhere, which increases the size of
+-- the generated parser quite a bit.
 
 {-# NOINLINE happyDoAction #-}
 {-# NOINLINE happyTable #-}
diff --git a/src/Language/Clafer/Front/ParClafer.y b/src/Language/Clafer/Front/ParClafer.y
new file mode 100644
--- /dev/null
+++ b/src/Language/Clafer/Front/ParClafer.y
@@ -0,0 +1,429 @@
+-- This Happy file was machine-generated by the BNF converter
+{
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
+module Language.Clafer.Front.ParClafer where
+import Language.Clafer.Front.AbsClafer
+import Language.Clafer.Front.LexClafer
+import Language.Clafer.Front.ErrM
+
+}
+
+%name pModule Module
+%name pClafer Clafer
+%name pConstraint Constraint
+%name pAssertion Assertion
+%name pGoal Goal
+-- no lexer declaration
+%monad { Err } { thenM } { returnM }
+%tokentype {Token}
+%token
+  '!' { PT _ (TS _ 1) }
+  '!=' { PT _ (TS _ 2) }
+  '#' { PT _ (TS _ 3) }
+  '%' { PT _ (TS _ 4) }
+  '&' { PT _ (TS _ 5) }
+  '&&' { PT _ (TS _ 6) }
+  '(' { PT _ (TS _ 7) }
+  ')' { PT _ (TS _ 8) }
+  '*' { PT _ (TS _ 9) }
+  '**' { PT _ (TS _ 10) }
+  '+' { PT _ (TS _ 11) }
+  '++' { PT _ (TS _ 12) }
+  ',' { PT _ (TS _ 13) }
+  '-' { PT _ (TS _ 14) }
+  '--' { PT _ (TS _ 15) }
+  '-->' { PT _ (TS _ 16) }
+  '-->>' { PT _ (TS _ 17) }
+  '->' { PT _ (TS _ 18) }
+  '->>' { PT _ (TS _ 19) }
+  '-[' { PT _ (TS _ 20) }
+  '.' { PT _ (TS _ 21) }
+  '..' { PT _ (TS _ 22) }
+  '/' { PT _ (TS _ 23) }
+  ':' { PT _ (TS _ 24) }
+  ':=' { PT _ (TS _ 25) }
+  ':>' { PT _ (TS _ 26) }
+  ';' { PT _ (TS _ 27) }
+  L_sep { PT _ (TS _ 101) }
+  '<' { PT _ (TS _ 28) }
+  '<:' { PT _ (TS _ 29) }
+  '<<' { PT _ (TS _ 30) }
+  '<=' { PT _ (TS _ 31) }
+  '<=>' { PT _ (TS _ 32) }
+  '=' { PT _ (TS _ 33) }
+  '=>' { PT _ (TS _ 34) }
+  '>' { PT _ (TS _ 35) }
+  '>=' { PT _ (TS _ 36) }
+  '>>' { PT _ (TS _ 37) }
+  '?' { PT _ (TS _ 38) }
+  'F' { PT _ (TS _ 39) }
+  'G' { PT _ (TS _ 40) }
+  'U' { PT _ (TS _ 41) }
+  'W' { PT _ (TS _ 42) }
+  'X' { PT _ (TS _ 43) }
+  '[' { PT _ (TS _ 44) }
+  '\\' { PT _ (TS _ 45) }
+  ']' { PT _ (TS _ 46) }
+  ']->' { PT _ (TS _ 47) }
+  ']->>' { PT _ (TS _ 48) }
+  '`' { PT _ (TS _ 49) }
+  'abstract' { PT _ (TS _ 50) }
+  'after' { PT _ (TS _ 51) }
+  'all' { PT _ (TS _ 52) }
+  'always' { PT _ (TS _ 53) }
+  'and' { PT _ (TS _ 54) }
+  'assert' { PT _ (TS _ 55) }
+  'before' { PT _ (TS _ 56) }
+  'between' { PT _ (TS _ 57) }
+  'disj' { PT _ (TS _ 58) }
+  'else' { PT _ (TS _ 59) }
+  'enum' { PT _ (TS _ 60) }
+  'eventually' { PT _ (TS _ 61) }
+  'final' { PT _ (TS _ 62) }
+  'finally' { PT _ (TS _ 63) }
+  'finalref' { PT _ (TS _ 64) }
+  'finaltarget' { PT _ (TS _ 65) }
+  'follow' { PT _ (TS _ 66) }
+  'globally' { PT _ (TS _ 67) }
+  'if' { PT _ (TS _ 68) }
+  'in' { PT _ (TS _ 69) }
+  'initial' { PT _ (TS _ 70) }
+  'initially' { PT _ (TS _ 71) }
+  'let' { PT _ (TS _ 72) }
+  'lonce' { PT _ (TS _ 73) }
+  'lone' { PT _ (TS _ 74) }
+  'max' { PT _ (TS _ 75) }
+  'maximize' { PT _ (TS _ 76) }
+  'min' { PT _ (TS _ 77) }
+  'minimize' { PT _ (TS _ 78) }
+  'must' { PT _ (TS _ 79) }
+  'mux' { PT _ (TS _ 80) }
+  'never' { PT _ (TS _ 81) }
+  'next' { PT _ (TS _ 82) }
+  'no' { PT _ (TS _ 83) }
+  'not' { PT _ (TS _ 84) }
+  'one' { PT _ (TS _ 85) }
+  'opt' { PT _ (TS _ 86) }
+  'or' { PT _ (TS _ 87) }
+  'precede' { PT _ (TS _ 88) }
+  'product' { PT _ (TS _ 89) }
+  'some' { PT _ (TS _ 90) }
+  'sometime' { PT _ (TS _ 91) }
+  'sum' { PT _ (TS _ 92) }
+  'then' { PT _ (TS _ 93) }
+  'until' { PT _ (TS _ 94) }
+  'weakuntil' { PT _ (TS _ 95) }
+  'xor' { PT _ (TS _ 96) }
+  '{' { PT _ (TS _ 97) }
+  '|' { PT _ (TS _ 98) }
+  '||' { PT _ (TS _ 99) }
+  '}' { PT _ (TS _ 100) }
+
+L_PosInteger { PT _ (T_PosInteger _) }
+L_PosDouble { PT _ (T_PosDouble _) }
+L_PosReal { PT _ (T_PosReal _) }
+L_PosString { PT _ (T_PosString _) }
+L_PosIdent { PT _ (T_PosIdent _) }
+L_PosLineComment { PT _ (T_PosLineComment _) }
+L_PosBlockComment { PT _ (T_PosBlockComment _) }
+L_PosAlloy { PT _ (T_PosAlloy _) }
+L_PosChoco { PT _ (T_PosChoco _) }
+
+
+%%
+
+PosInteger    :: { PosInteger} : L_PosInteger { PosInteger (mkPosToken $1)}
+PosDouble    :: { PosDouble} : L_PosDouble { PosDouble (mkPosToken $1)}
+PosReal    :: { PosReal} : L_PosReal { PosReal (mkPosToken $1)}
+PosString    :: { PosString} : L_PosString { PosString (mkPosToken $1)}
+PosIdent    :: { PosIdent} : L_PosIdent { PosIdent (mkPosToken $1)}
+PosLineComment    :: { PosLineComment} : L_PosLineComment { PosLineComment (mkPosToken $1)}
+PosBlockComment    :: { PosBlockComment} : L_PosBlockComment { PosBlockComment (mkPosToken $1)}
+PosAlloy    :: { PosAlloy} : L_PosAlloy { PosAlloy (mkPosToken $1)}
+PosChoco    :: { PosChoco} : L_PosChoco { PosChoco (mkPosToken $1)}
+
+Module :: { Module }
+Module : ListDeclaration { Language.Clafer.Front.AbsClafer.Module ((mkCatSpan $1)) (reverse $1) }
+Declaration :: { Declaration }
+Declaration : 'enum' PosIdent '=' ListEnumId { Language.Clafer.Front.AbsClafer.EnumDecl ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
+            | Element { Language.Clafer.Front.AbsClafer.ElementDecl ((mkCatSpan $1)) $1 }
+Clafer :: { Clafer }
+Clafer : Abstract ListTempModifier GCard PosIdent Super Reference Card Init Transition Elements { Language.Clafer.Front.AbsClafer.Clafer ((mkCatSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3) >- (mkCatSpan $4) >- (mkCatSpan $5) >- (mkCatSpan $6) >- (mkCatSpan $7) >- (mkCatSpan $8) >- (mkCatSpan $9) >- (mkCatSpan $10)) $1 (reverse $2) $3 $4 $5 $6 $7 $8 $9 $10 }
+Constraint :: { Constraint }
+Constraint : '[' ListExp ']' { Language.Clafer.Front.AbsClafer.Constraint ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) (reverse $2) }
+Assertion :: { Assertion }
+Assertion : 'assert' '[' ListExp ']' { Language.Clafer.Front.AbsClafer.Assertion ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4)) (reverse $3) }
+Goal :: { Goal }
+Goal : '<<' 'min' ListExp '>>' { Language.Clafer.Front.AbsClafer.GoalMinDeprecated ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4)) (reverse $3) }
+     | '<<' 'max' ListExp '>>' { Language.Clafer.Front.AbsClafer.GoalMaxDeprecated ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4)) (reverse $3) }
+     | '<<' 'minimize' ListExp '>>' { Language.Clafer.Front.AbsClafer.GoalMinimize ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4)) (reverse $3) }
+     | '<<' 'maximize' ListExp '>>' { Language.Clafer.Front.AbsClafer.GoalMaximize ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4)) (reverse $3) }
+TempModifier :: { TempModifier }
+TempModifier : 'initial' { Language.Clafer.Front.AbsClafer.Initial ((mkTokenSpan $1)) }
+             | 'final' { Language.Clafer.Front.AbsClafer.Final ((mkTokenSpan $1)) }
+             | 'finalref' { Language.Clafer.Front.AbsClafer.FinalRef ((mkTokenSpan $1)) }
+             | 'finaltarget' { Language.Clafer.Front.AbsClafer.FinalTarget ((mkTokenSpan $1)) }
+Transition :: { Transition }
+Transition : {- empty -} { Language.Clafer.Front.AbsClafer.TransitionEmpty noSpan }
+           | TransArrow Exp { Language.Clafer.Front.AbsClafer.Transition ((mkCatSpan $1) >- (mkCatSpan $2)) $1 $2 }
+Abstract :: { Abstract }
+Abstract : {- empty -} { Language.Clafer.Front.AbsClafer.AbstractEmpty noSpan }
+         | 'abstract' { Language.Clafer.Front.AbsClafer.Abstract ((mkTokenSpan $1)) }
+Elements :: { Elements }
+Elements : {- empty -} { Language.Clafer.Front.AbsClafer.ElementsEmpty noSpan }
+         | '{' ListElement '}' { Language.Clafer.Front.AbsClafer.ElementsList ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) (reverse $2) }
+Element :: { Element }
+Element : Clafer { Language.Clafer.Front.AbsClafer.Subclafer ((mkCatSpan $1)) $1 }
+        | '`' Name Card Elements { Language.Clafer.Front.AbsClafer.ClaferUse ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3) >- (mkCatSpan $4)) $2 $3 $4 }
+        | Constraint { Language.Clafer.Front.AbsClafer.Subconstraint ((mkCatSpan $1)) $1 }
+        | Goal { Language.Clafer.Front.AbsClafer.Subgoal ((mkCatSpan $1)) $1 }
+        | Assertion { Language.Clafer.Front.AbsClafer.SubAssertion ((mkCatSpan $1)) $1 }
+Super :: { Super }
+Super : {- empty -} { Language.Clafer.Front.AbsClafer.SuperEmpty noSpan }
+      | ':' Exp26 { Language.Clafer.Front.AbsClafer.SuperSome ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+Reference :: { Reference }
+Reference : {- empty -} { Language.Clafer.Front.AbsClafer.ReferenceEmpty noSpan }
+          | '->' Exp23 { Language.Clafer.Front.AbsClafer.ReferenceSet ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+          | '->>' Exp23 { Language.Clafer.Front.AbsClafer.ReferenceBag ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+Init :: { Init }
+Init : {- empty -} { Language.Clafer.Front.AbsClafer.InitEmpty noSpan }
+     | InitHow Exp { Language.Clafer.Front.AbsClafer.InitSome ((mkCatSpan $1) >- (mkCatSpan $2)) $1 $2 }
+InitHow :: { InitHow }
+InitHow : '=' { Language.Clafer.Front.AbsClafer.InitConstant ((mkTokenSpan $1)) }
+        | ':=' { Language.Clafer.Front.AbsClafer.InitDefault ((mkTokenSpan $1)) }
+GCard :: { GCard }
+GCard : {- empty -} { Language.Clafer.Front.AbsClafer.GCardEmpty noSpan }
+      | 'xor' { Language.Clafer.Front.AbsClafer.GCardXor ((mkTokenSpan $1)) }
+      | 'or' { Language.Clafer.Front.AbsClafer.GCardOr ((mkTokenSpan $1)) }
+      | 'mux' { Language.Clafer.Front.AbsClafer.GCardMux ((mkTokenSpan $1)) }
+      | 'opt' { Language.Clafer.Front.AbsClafer.GCardOpt ((mkTokenSpan $1)) }
+      | NCard { Language.Clafer.Front.AbsClafer.GCardInterval ((mkCatSpan $1)) $1 }
+Card :: { Card }
+Card : {- empty -} { Language.Clafer.Front.AbsClafer.CardEmpty noSpan }
+     | '?' { Language.Clafer.Front.AbsClafer.CardLone ((mkTokenSpan $1)) }
+     | '+' { Language.Clafer.Front.AbsClafer.CardSome ((mkTokenSpan $1)) }
+     | '*' { Language.Clafer.Front.AbsClafer.CardAny ((mkTokenSpan $1)) }
+     | PosInteger { Language.Clafer.Front.AbsClafer.CardNum ((mkCatSpan $1)) $1 }
+     | NCard { Language.Clafer.Front.AbsClafer.CardInterval ((mkCatSpan $1)) $1 }
+NCard :: { NCard }
+NCard : PosInteger '..' ExInteger { Language.Clafer.Front.AbsClafer.NCard ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+ExInteger :: { ExInteger }
+ExInteger : '*' { Language.Clafer.Front.AbsClafer.ExIntegerAst ((mkTokenSpan $1)) }
+          | PosInteger { Language.Clafer.Front.AbsClafer.ExIntegerNum ((mkCatSpan $1)) $1 }
+Name :: { Name }
+Name : ListModId { Language.Clafer.Front.AbsClafer.Path ((mkCatSpan $1)) $1 }
+Exp :: { Exp }
+Exp : Exp1 TransArrow Exp { Language.Clafer.Front.AbsClafer.TransitionExp ((mkCatSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3)) $1 $2 $3 }
+    | Exp1 {  $1 }
+Exp1 :: { Exp }
+Exp1 : 'all' 'disj' Decl '|' Exp1 { Language.Clafer.Front.AbsClafer.EDeclAllDisj ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4) >- (mkCatSpan $5)) $3 $5 }
+     | 'all' Decl '|' Exp1 { Language.Clafer.Front.AbsClafer.EDeclAll ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
+     | Quant 'disj' Decl '|' Exp1 { Language.Clafer.Front.AbsClafer.EDeclQuantDisj ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4) >- (mkCatSpan $5)) $1 $3 $5 }
+     | Quant Decl '|' Exp1 { Language.Clafer.Front.AbsClafer.EDeclQuant ((mkCatSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $1 $2 $4 }
+     | 'if' Exp1 'then' Exp1 'else' Exp1 { Language.Clafer.Front.AbsClafer.EImpliesElse ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4) >- (mkTokenSpan $5) >- (mkCatSpan $6)) $2 $4 $6 }
+     | 'let' VarBinding 'in' Exp1 { Language.Clafer.Front.AbsClafer.LetExp ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
+     | Exp2 {  $1 }
+Exp2 :: { Exp }
+Exp2 : 'never' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatNever ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3)) $2 $3 }
+     | 'sometime' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatSometime ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3)) $2 $3 }
+     | 'lonce' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatLessOrOnce ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3)) $2 $3 }
+     | 'always' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatAlways ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3)) $2 $3 }
+     | Exp3 'must' 'precede' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatPrecede ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4) >- (mkCatSpan $5)) $1 $4 $5 }
+     | Exp3 'must' 'follow' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatFollow ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4) >- (mkCatSpan $5)) $1 $4 $5 }
+     | 'initially' Exp3 { Language.Clafer.Front.AbsClafer.TmpInitially ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+     | 'finally' Exp3 { Language.Clafer.Front.AbsClafer.TmpFinally ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+     | Exp3 {  $1 }
+Exp3 :: { Exp }
+Exp3 : Exp3 '<=>' Exp4 { Language.Clafer.Front.AbsClafer.EIff ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+     | Exp4 {  $1 }
+Exp4 :: { Exp }
+Exp4 : Exp4 '=>' Exp5 { Language.Clafer.Front.AbsClafer.EImplies ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+     | Exp5 {  $1 }
+Exp5 :: { Exp }
+Exp5 : Exp5 '||' Exp6 { Language.Clafer.Front.AbsClafer.EOr ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+     | Exp6 {  $1 }
+Exp6 :: { Exp }
+Exp6 : Exp6 'xor' Exp7 { Language.Clafer.Front.AbsClafer.EXor ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+     | Exp7 {  $1 }
+Exp7 :: { Exp }
+Exp7 : Exp7 '&&' Exp8 { Language.Clafer.Front.AbsClafer.EAnd ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+     | Exp8 {  $1 }
+Exp8 :: { Exp }
+Exp8 : Exp8 'U' Exp9 { Language.Clafer.Front.AbsClafer.LtlU ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+     | Exp8 'until' Exp9 { Language.Clafer.Front.AbsClafer.TmpUntil ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+     | Exp9 {  $1 }
+Exp9 :: { Exp }
+Exp9 : Exp9 'W' Exp10 { Language.Clafer.Front.AbsClafer.LtlW ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+     | Exp9 'weakuntil' Exp10 { Language.Clafer.Front.AbsClafer.TmpWUntil ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+     | Exp10 {  $1 }
+Exp10 :: { Exp }
+Exp10 : 'F' Exp10 { Language.Clafer.Front.AbsClafer.LtlF ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | 'eventually' Exp10 { Language.Clafer.Front.AbsClafer.TmpEventually ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | 'G' Exp10 { Language.Clafer.Front.AbsClafer.LtlG ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | 'globally' Exp10 { Language.Clafer.Front.AbsClafer.TmpGlobally ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | 'X' Exp10 { Language.Clafer.Front.AbsClafer.LtlX ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | 'next' Exp10 { Language.Clafer.Front.AbsClafer.TmpNext ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | Exp11 {  $1 }
+Exp11 :: { Exp }
+Exp11 : '!' Exp11 { Language.Clafer.Front.AbsClafer.ENeg ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | Exp12 {  $1 }
+Exp15 :: { Exp }
+Exp15 : Exp15 '<' Exp16 { Language.Clafer.Front.AbsClafer.ELt ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp15 '>' Exp16 { Language.Clafer.Front.AbsClafer.EGt ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp15 '=' Exp16 { Language.Clafer.Front.AbsClafer.EEq ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp15 '<=' Exp16 { Language.Clafer.Front.AbsClafer.ELte ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp15 '>=' Exp16 { Language.Clafer.Front.AbsClafer.EGte ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp15 '!=' Exp16 { Language.Clafer.Front.AbsClafer.ENeq ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp15 'in' Exp16 { Language.Clafer.Front.AbsClafer.EIn ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp15 'not' 'in' Exp16 { Language.Clafer.Front.AbsClafer.ENin ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $1 $4 }
+      | Exp16 {  $1 }
+Exp16 :: { Exp }
+Exp16 : Quant Exp20 { Language.Clafer.Front.AbsClafer.EQuantExp ((mkCatSpan $1) >- (mkCatSpan $2)) $1 $2 }
+      | Exp17 {  $1 }
+Exp17 :: { Exp }
+Exp17 : Exp17 '+' Exp18 { Language.Clafer.Front.AbsClafer.EAdd ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp17 '-' Exp18 { Language.Clafer.Front.AbsClafer.ESub ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp18 {  $1 }
+Exp18 :: { Exp }
+Exp18 : Exp18 '*' Exp19 { Language.Clafer.Front.AbsClafer.EMul ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp18 '/' Exp19 { Language.Clafer.Front.AbsClafer.EDiv ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp18 '%' Exp19 { Language.Clafer.Front.AbsClafer.ERem ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp19 {  $1 }
+Exp19 :: { Exp }
+Exp19 : 'max' Exp20 { Language.Clafer.Front.AbsClafer.EGMax ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | 'min' Exp20 { Language.Clafer.Front.AbsClafer.EGMin ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | Exp20 {  $1 }
+Exp20 :: { Exp }
+Exp20 : 'sum' Exp21 { Language.Clafer.Front.AbsClafer.ESum ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | 'product' Exp21 { Language.Clafer.Front.AbsClafer.EProd ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | '#' Exp21 { Language.Clafer.Front.AbsClafer.ECard ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | '-' Exp21 { Language.Clafer.Front.AbsClafer.EMinExp ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+      | Exp21 {  $1 }
+Exp21 :: { Exp }
+Exp21 : Exp21 '<:' Exp22 { Language.Clafer.Front.AbsClafer.EDomain ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp22 {  $1 }
+Exp22 :: { Exp }
+Exp22 : Exp22 ':>' Exp23 { Language.Clafer.Front.AbsClafer.ERange ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp23 {  $1 }
+Exp23 :: { Exp }
+Exp23 : Exp23 '++' Exp24 { Language.Clafer.Front.AbsClafer.EUnion ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp23 ',' Exp24 { Language.Clafer.Front.AbsClafer.EUnionCom ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp24 {  $1 }
+Exp24 :: { Exp }
+Exp24 : Exp24 '--' Exp25 { Language.Clafer.Front.AbsClafer.EDifference ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp25 {  $1 }
+Exp25 :: { Exp }
+Exp25 : Exp25 '**' Exp26 { Language.Clafer.Front.AbsClafer.EIntersection ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp26 {  $1 }
+Exp26 :: { Exp }
+Exp26 : Exp26 '&' Exp27 { Language.Clafer.Front.AbsClafer.EIntersectionDeprecated ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp26 '.' Exp27 { Language.Clafer.Front.AbsClafer.EJoin ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+      | Exp27 {  $1 }
+Exp27 :: { Exp }
+Exp27 : Name { Language.Clafer.Front.AbsClafer.ClaferId ((mkCatSpan $1)) $1 }
+      | PosInteger { Language.Clafer.Front.AbsClafer.EInt ((mkCatSpan $1)) $1 }
+      | PosDouble { Language.Clafer.Front.AbsClafer.EDouble ((mkCatSpan $1)) $1 }
+      | PosReal { Language.Clafer.Front.AbsClafer.EReal ((mkCatSpan $1)) $1 }
+      | PosString { Language.Clafer.Front.AbsClafer.EStr ((mkCatSpan $1)) $1 }
+      | '(' Exp ')' {  $2 }
+TransGuard :: { TransGuard }
+TransGuard : Exp1 { Language.Clafer.Front.AbsClafer.TransGuard ((mkCatSpan $1)) $1 }
+TransArrow :: { TransArrow }
+TransArrow : '-->>' { Language.Clafer.Front.AbsClafer.SyncTransArrow ((mkTokenSpan $1)) }
+           | '-[' TransGuard ']->>' { Language.Clafer.Front.AbsClafer.GuardedSyncTransArrow ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) $2 }
+           | '-->' { Language.Clafer.Front.AbsClafer.NextTransArrow ((mkTokenSpan $1)) }
+           | '-[' TransGuard ']->' { Language.Clafer.Front.AbsClafer.GuardedNextTransArrow ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) $2 }
+PatternScope :: { PatternScope }
+PatternScope : 'before' Exp11 { Language.Clafer.Front.AbsClafer.PatScopeBefore ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+             | 'after' Exp11 { Language.Clafer.Front.AbsClafer.PatScopeAfter ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+             | 'between' Exp11 'and' Exp11 { Language.Clafer.Front.AbsClafer.PatScopeBetweenAnd ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
+             | 'after' Exp11 'until' Exp11 { Language.Clafer.Front.AbsClafer.PatScopeAfterUntil ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
+             | {- empty -} { Language.Clafer.Front.AbsClafer.PatScopeEmpty noSpan }
+Decl :: { Decl }
+Decl : ListLocId ':' Exp21 { Language.Clafer.Front.AbsClafer.Decl ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+VarBinding :: { VarBinding }
+VarBinding : LocId '=' Exp16 { Language.Clafer.Front.AbsClafer.VarBinding ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+Quant :: { Quant }
+Quant : 'no' { Language.Clafer.Front.AbsClafer.QuantNo ((mkTokenSpan $1)) }
+      | 'not' { Language.Clafer.Front.AbsClafer.QuantNot ((mkTokenSpan $1)) }
+      | 'lone' { Language.Clafer.Front.AbsClafer.QuantLone ((mkTokenSpan $1)) }
+      | 'one' { Language.Clafer.Front.AbsClafer.QuantOne ((mkTokenSpan $1)) }
+      | 'some' { Language.Clafer.Front.AbsClafer.QuantSome ((mkTokenSpan $1)) }
+EnumId :: { EnumId }
+EnumId : PosIdent { Language.Clafer.Front.AbsClafer.EnumIdIdent ((mkCatSpan $1)) $1 }
+ModId :: { ModId }
+ModId : PosIdent { Language.Clafer.Front.AbsClafer.ModIdIdent ((mkCatSpan $1)) $1 }
+LocId :: { LocId }
+LocId : PosIdent { Language.Clafer.Front.AbsClafer.LocIdIdent ((mkCatSpan $1)) $1 }
+ListDeclaration :: { [Declaration] }
+ListDeclaration : {- empty -} { []  }
+                | ListDeclaration Declaration { flip (:)  $1 $2 }
+                | ListDeclaration L_sep { $1 }
+ListEnumId :: { [EnumId] }
+ListEnumId : EnumId { (:[])  $1 }
+           | EnumId '|' ListEnumId { (:)  $1 $3 }
+ListElement :: { [Element] }
+ListElement : {- empty -} { []  }
+            | ListElement Element { flip (:)  $1 $2 }
+            | ListElement L_sep { $1 }
+ListExp :: { [Exp] }
+ListExp : {- empty -} { []  } | ListExp Exp { flip (:)  $1 $2 }
+ListTempModifier :: { [TempModifier] }
+ListTempModifier : {- empty -} { []  }
+                 | ListTempModifier TempModifier { flip (:)  $1 $2 }
+ListLocId :: { [LocId] }
+ListLocId : LocId { (:[])  $1 }
+          | LocId ';' ListLocId { (:)  $1 $3 }
+ListModId :: { [ModId] }
+ListModId : ModId { (:[])  $1 }
+          | ModId '\\' ListModId { (:)  $1 $3 }
+Exp12 :: { Exp }
+Exp12 : Exp13 {  $1 }
+Exp13 :: { Exp }
+Exp13 : Exp14 {  $1 }
+Exp14 :: { Exp }
+Exp14 : Exp15 {  $1 }
+{
+
+returnM :: a -> Err a
+returnM = return
+
+thenM :: Err a -> (a -> Err b) -> Err b
+thenM = (>>=)
+
+happyError :: [Token] -> Err a
+-- | The separator of sibling lines, which the layout resolver inserts, e.g., in @a ; 2..3 b@,
+--   so that a group cardinality at the start of a line is not the cardinality of the clafer on
+--   the line before. It is not a reserved symbol, so a model cannot contain it.
+layoutSeparator :: Token
+layoutSeparator = PT (Pn 0 0 0) (TS "" 101)
+
+isLayoutSeparator :: Token -> Bool
+isLayoutSeparator (PT _ (TS _ 101)) = True
+isLayoutSeparator _ = False
+
+happyError ts' =
+  -- the position is reported with the error; in a model of several files, the line of the
+  -- token is a line of the complete model. The separators inserted by the layout resolver
+  -- are not shown.
+  let ts = filter (not . isLayoutSeparator) ts' in
+  Bad (pp ts) $ "syntax error" ++
+  case ts of
+    [] -> " at end of file"
+    [Err _] -> " due to lexer error"
+    _ -> " before " ++ unwords (map (id . prToken) (take 4 ts))
+
+myLexer = tokens
+
+gp x@(PT (Pn _ l c) _) = Span (Pos (toInteger l) (toInteger c)) (Pos (toInteger l) (toInteger c + toInteger (length $ prToken x)))
+pp (PT (Pn _ l c) _ :_) = Pos (toInteger l) (toInteger c)
+pp (Err (Pn _ l c) :_) = Pos (toInteger l) (toInteger c)
+pp _ = error "EOF"
+
+mkCatSpan :: (Spannable c) => c -> Span
+mkCatSpan = getSpan
+
+mkTokenSpan :: Token -> Span
+mkTokenSpan = gp
+}
+
diff --git a/src/Language/Clafer/Front/PrintClafer.hs b/src/Language/Clafer/Front/PrintClafer.hs
--- a/src/Language/Clafer/Front/PrintClafer.hs
+++ b/src/Language/Clafer/Front/PrintClafer.hs
@@ -128,7 +128,7 @@
   prtList _ (x:xs) = (concatD [prt 0 x, prt 0 xs])
 instance Print Clafer where
   prt i e = case e of
-    Clafer _ abstract gcard posident super reference card init elements -> prPrec i 0 (concatD [prt 0 abstract, prt 0 gcard, prt 0 posident, prt 0 super, prt 0 reference, prt 0 card, prt 0 init, prt 0 elements])
+    Clafer _ abstract tempmodifiers gcard posident super reference card init transition elements -> prPrec i 0 (concatD [prt 0 abstract, prt 0 tempmodifiers, prt 0 gcard, prt 0 posident, prt 0 super, prt 0 reference, prt 0 card, prt 0 init, prt 0 transition, prt 0 elements])
 
 instance Print Constraint where
   prt i e = case e of
@@ -145,6 +145,19 @@
     GoalMinimize _ exps -> prPrec i 0 (concatD [doc (showString "<<"), doc (showString "minimize"), prt 0 exps, doc (showString ">>")])
     GoalMaximize _ exps -> prPrec i 0 (concatD [doc (showString "<<"), doc (showString "maximize"), prt 0 exps, doc (showString ">>")])
 
+instance Print TempModifier where
+  prt i e = case e of
+    Initial _ -> prPrec i 0 (concatD [doc (showString "initial")])
+    Final _ -> prPrec i 0 (concatD [doc (showString "final")])
+    FinalRef _ -> prPrec i 0 (concatD [doc (showString "finalref")])
+    FinalTarget _ -> prPrec i 0 (concatD [doc (showString "finaltarget")])
+  prtList _ [] = (concatD [])
+  prtList _ (x:xs) = (concatD [prt 0 x, prt 0 xs])
+instance Print Transition where
+  prt i e = case e of
+    TransitionEmpty _ -> prPrec i 0 (concatD [])
+    Transition _ transarrow exp -> prPrec i 0 (concatD [prt 0 transarrow, prt 0 exp])
+
 instance Print Abstract where
   prt i e = case e of
     AbstractEmpty _ -> prPrec i 0 (concatD [])
@@ -167,13 +180,13 @@
 instance Print Super where
   prt i e = case e of
     SuperEmpty _ -> prPrec i 0 (concatD [])
-    SuperSome _ exp -> prPrec i 0 (concatD [doc (showString ":"), prt 18 exp])
+    SuperSome _ exp -> prPrec i 0 (concatD [doc (showString ":"), prt 26 exp])
 
 instance Print Reference where
   prt i e = case e of
     ReferenceEmpty _ -> prPrec i 0 (concatD [])
-    ReferenceSet _ exp -> prPrec i 0 (concatD [doc (showString "->"), prt 15 exp])
-    ReferenceBag _ exp -> prPrec i 0 (concatD [doc (showString "->>"), prt 15 exp])
+    ReferenceSet _ exp -> prPrec i 0 (concatD [doc (showString "->"), prt 23 exp])
+    ReferenceBag _ exp -> prPrec i 0 (concatD [doc (showString "->>"), prt 23 exp])
 
 instance Print Init where
   prt i e = case e of
@@ -218,56 +231,99 @@
 
 instance Print Exp where
   prt i e = case e of
-    EDeclAllDisj _ decl exp -> prPrec i 0 (concatD [doc (showString "all"), doc (showString "disj"), prt 0 decl, doc (showString "|"), prt 0 exp])
-    EDeclAll _ decl exp -> prPrec i 0 (concatD [doc (showString "all"), prt 0 decl, doc (showString "|"), prt 0 exp])
-    EDeclQuantDisj _ quant decl exp -> prPrec i 0 (concatD [prt 0 quant, doc (showString "disj"), prt 0 decl, doc (showString "|"), prt 0 exp])
-    EDeclQuant _ quant decl exp -> prPrec i 0 (concatD [prt 0 quant, prt 0 decl, doc (showString "|"), prt 0 exp])
-    EImpliesElse _ exp1 exp2 exp3 -> prPrec i 0 (concatD [doc (showString "if"), prt 0 exp1, doc (showString "then"), prt 0 exp2, doc (showString "else"), prt 0 exp3])
-    EIff _ exp1 exp2 -> prPrec i 0 (concatD [prt 0 exp1, doc (showString "<=>"), prt 1 exp2])
-    EImplies _ exp1 exp2 -> prPrec i 2 (concatD [prt 2 exp1, doc (showString "=>"), prt 3 exp2])
-    EOr _ exp1 exp2 -> prPrec i 3 (concatD [prt 3 exp1, doc (showString "||"), prt 4 exp2])
-    EXor _ exp1 exp2 -> prPrec i 4 (concatD [prt 4 exp1, doc (showString "xor"), prt 5 exp2])
-    EAnd _ exp1 exp2 -> prPrec i 5 (concatD [prt 5 exp1, doc (showString "&&"), prt 6 exp2])
-    ENeg _ exp -> prPrec i 6 (concatD [doc (showString "!"), prt 7 exp])
-    ELt _ exp1 exp2 -> prPrec i 7 (concatD [prt 7 exp1, doc (showString "<"), prt 8 exp2])
-    EGt _ exp1 exp2 -> prPrec i 7 (concatD [prt 7 exp1, doc (showString ">"), prt 8 exp2])
-    EEq _ exp1 exp2 -> prPrec i 7 (concatD [prt 7 exp1, doc (showString "="), prt 8 exp2])
-    ELte _ exp1 exp2 -> prPrec i 7 (concatD [prt 7 exp1, doc (showString "<="), prt 8 exp2])
-    EGte _ exp1 exp2 -> prPrec i 7 (concatD [prt 7 exp1, doc (showString ">="), prt 8 exp2])
-    ENeq _ exp1 exp2 -> prPrec i 7 (concatD [prt 7 exp1, doc (showString "!="), prt 8 exp2])
-    EIn _ exp1 exp2 -> prPrec i 7 (concatD [prt 7 exp1, doc (showString "in"), prt 8 exp2])
-    ENin _ exp1 exp2 -> prPrec i 7 (concatD [prt 7 exp1, doc (showString "not"), doc (showString "in"), prt 8 exp2])
-    EQuantExp _ quant exp -> prPrec i 8 (concatD [prt 0 quant, prt 12 exp])
-    EAdd _ exp1 exp2 -> prPrec i 9 (concatD [prt 9 exp1, doc (showString "+"), prt 10 exp2])
-    ESub _ exp1 exp2 -> prPrec i 9 (concatD [prt 9 exp1, doc (showString "-"), prt 10 exp2])
-    EMul _ exp1 exp2 -> prPrec i 10 (concatD [prt 10 exp1, doc (showString "*"), prt 11 exp2])
-    EDiv _ exp1 exp2 -> prPrec i 10 (concatD [prt 10 exp1, doc (showString "/"), prt 11 exp2])
-    ERem _ exp1 exp2 -> prPrec i 10 (concatD [prt 10 exp1, doc (showString "%"), prt 11 exp2])
-    EGMax _ exp -> prPrec i 11 (concatD [doc (showString "max"), prt 12 exp])
-    EGMin _ exp -> prPrec i 11 (concatD [doc (showString "min"), prt 12 exp])
-    ESum _ exp -> prPrec i 12 (concatD [doc (showString "sum"), prt 13 exp])
-    EProd _ exp -> prPrec i 12 (concatD [doc (showString "product"), prt 13 exp])
-    ECard _ exp -> prPrec i 12 (concatD [doc (showString "#"), prt 13 exp])
-    EMinExp _ exp -> prPrec i 12 (concatD [doc (showString "-"), prt 13 exp])
-    EDomain _ exp1 exp2 -> prPrec i 13 (concatD [prt 13 exp1, doc (showString "<:"), prt 14 exp2])
-    ERange _ exp1 exp2 -> prPrec i 14 (concatD [prt 14 exp1, doc (showString ":>"), prt 15 exp2])
-    EUnion _ exp1 exp2 -> prPrec i 15 (concatD [prt 15 exp1, doc (showString "++"), prt 16 exp2])
-    EUnionCom _ exp1 exp2 -> prPrec i 15 (concatD [prt 15 exp1, doc (showString ","), prt 16 exp2])
-    EDifference _ exp1 exp2 -> prPrec i 16 (concatD [prt 16 exp1, doc (showString "--"), prt 17 exp2])
-    EIntersection _ exp1 exp2 -> prPrec i 17 (concatD [prt 17 exp1, doc (showString "**"), prt 18 exp2])
-    EIntersectionDeprecated _ exp1 exp2 -> prPrec i 17 (concatD [prt 17 exp1, doc (showString "&"), prt 18 exp2])
-    EJoin _ exp1 exp2 -> prPrec i 18 (concatD [prt 18 exp1, doc (showString "."), prt 19 exp2])
-    ClaferId _ name -> prPrec i 19 (concatD [prt 0 name])
-    EInt _ posinteger -> prPrec i 19 (concatD [prt 0 posinteger])
-    EDouble _ posdouble -> prPrec i 19 (concatD [prt 0 posdouble])
-    EReal _ posreal -> prPrec i 19 (concatD [prt 0 posreal])
-    EStr _ posstring -> prPrec i 19 (concatD [prt 0 posstring])
+    TransitionExp _ exp1 transarrow exp2 -> prPrec i 0 (concatD [prt 1 exp1, prt 0 transarrow, prt 0 exp2])
+    EDeclAllDisj _ decl exp -> prPrec i 1 (concatD [doc (showString "all"), doc (showString "disj"), prt 0 decl, doc (showString "|"), prt 1 exp])
+    EDeclAll _ decl exp -> prPrec i 1 (concatD [doc (showString "all"), prt 0 decl, doc (showString "|"), prt 1 exp])
+    EDeclQuantDisj _ quant decl exp -> prPrec i 1 (concatD [prt 0 quant, doc (showString "disj"), prt 0 decl, doc (showString "|"), prt 1 exp])
+    EDeclQuant _ quant decl exp -> prPrec i 1 (concatD [prt 0 quant, prt 0 decl, doc (showString "|"), prt 1 exp])
+    EImpliesElse _ exp1 exp2 exp3 -> prPrec i 1 (concatD [doc (showString "if"), prt 1 exp1, doc (showString "then"), prt 1 exp2, doc (showString "else"), prt 1 exp3])
+    LetExp _ varbinding exp -> prPrec i 1 (concatD [doc (showString "let"), prt 0 varbinding, doc (showString "in"), prt 1 exp])
+    TmpPatNever _ exp patternscope -> prPrec i 2 (concatD [doc (showString "never"), prt 3 exp, prt 0 patternscope])
+    TmpPatSometime _ exp patternscope -> prPrec i 2 (concatD [doc (showString "sometime"), prt 3 exp, prt 0 patternscope])
+    TmpPatLessOrOnce _ exp patternscope -> prPrec i 2 (concatD [doc (showString "lonce"), prt 3 exp, prt 0 patternscope])
+    TmpPatAlways _ exp patternscope -> prPrec i 2 (concatD [doc (showString "always"), prt 3 exp, prt 0 patternscope])
+    TmpPatPrecede _ exp1 exp2 patternscope -> prPrec i 2 (concatD [prt 3 exp1, doc (showString "must"), doc (showString "precede"), prt 3 exp2, prt 0 patternscope])
+    TmpPatFollow _ exp1 exp2 patternscope -> prPrec i 2 (concatD [prt 3 exp1, doc (showString "must"), doc (showString "follow"), prt 3 exp2, prt 0 patternscope])
+    TmpInitially _ exp -> prPrec i 2 (concatD [doc (showString "initially"), prt 3 exp])
+    TmpFinally _ exp -> prPrec i 2 (concatD [doc (showString "finally"), prt 3 exp])
+    EIff _ exp1 exp2 -> prPrec i 3 (concatD [prt 3 exp1, doc (showString "<=>"), prt 4 exp2])
+    EImplies _ exp1 exp2 -> prPrec i 4 (concatD [prt 4 exp1, doc (showString "=>"), prt 5 exp2])
+    EOr _ exp1 exp2 -> prPrec i 5 (concatD [prt 5 exp1, doc (showString "||"), prt 6 exp2])
+    EXor _ exp1 exp2 -> prPrec i 6 (concatD [prt 6 exp1, doc (showString "xor"), prt 7 exp2])
+    EAnd _ exp1 exp2 -> prPrec i 7 (concatD [prt 7 exp1, doc (showString "&&"), prt 8 exp2])
+    LtlU _ exp1 exp2 -> prPrec i 8 (concatD [prt 8 exp1, doc (showString "U"), prt 9 exp2])
+    TmpUntil _ exp1 exp2 -> prPrec i 8 (concatD [prt 8 exp1, doc (showString "until"), prt 9 exp2])
+    LtlW _ exp1 exp2 -> prPrec i 9 (concatD [prt 9 exp1, doc (showString "W"), prt 10 exp2])
+    TmpWUntil _ exp1 exp2 -> prPrec i 9 (concatD [prt 9 exp1, doc (showString "weakuntil"), prt 10 exp2])
+    LtlF _ exp -> prPrec i 10 (concatD [doc (showString "F"), prt 10 exp])
+    TmpEventually _ exp -> prPrec i 10 (concatD [doc (showString "eventually"), prt 10 exp])
+    LtlG _ exp -> prPrec i 10 (concatD [doc (showString "G"), prt 10 exp])
+    TmpGlobally _ exp -> prPrec i 10 (concatD [doc (showString "globally"), prt 10 exp])
+    LtlX _ exp -> prPrec i 10 (concatD [doc (showString "X"), prt 10 exp])
+    TmpNext _ exp -> prPrec i 10 (concatD [doc (showString "next"), prt 10 exp])
+    ENeg _ exp -> prPrec i 11 (concatD [doc (showString "!"), prt 11 exp])
+    ELt _ exp1 exp2 -> prPrec i 15 (concatD [prt 15 exp1, doc (showString "<"), prt 16 exp2])
+    EGt _ exp1 exp2 -> prPrec i 15 (concatD [prt 15 exp1, doc (showString ">"), prt 16 exp2])
+    EEq _ exp1 exp2 -> prPrec i 15 (concatD [prt 15 exp1, doc (showString "="), prt 16 exp2])
+    ELte _ exp1 exp2 -> prPrec i 15 (concatD [prt 15 exp1, doc (showString "<="), prt 16 exp2])
+    EGte _ exp1 exp2 -> prPrec i 15 (concatD [prt 15 exp1, doc (showString ">="), prt 16 exp2])
+    ENeq _ exp1 exp2 -> prPrec i 15 (concatD [prt 15 exp1, doc (showString "!="), prt 16 exp2])
+    EIn _ exp1 exp2 -> prPrec i 15 (concatD [prt 15 exp1, doc (showString "in"), prt 16 exp2])
+    ENin _ exp1 exp2 -> prPrec i 15 (concatD [prt 15 exp1, doc (showString "not"), doc (showString "in"), prt 16 exp2])
+    EQuantExp _ quant exp -> prPrec i 16 (concatD [prt 0 quant, prt 20 exp])
+    EAdd _ exp1 exp2 -> prPrec i 17 (concatD [prt 17 exp1, doc (showString "+"), prt 18 exp2])
+    ESub _ exp1 exp2 -> prPrec i 17 (concatD [prt 17 exp1, doc (showString "-"), prt 18 exp2])
+    EMul _ exp1 exp2 -> prPrec i 18 (concatD [prt 18 exp1, doc (showString "*"), prt 19 exp2])
+    EDiv _ exp1 exp2 -> prPrec i 18 (concatD [prt 18 exp1, doc (showString "/"), prt 19 exp2])
+    ERem _ exp1 exp2 -> prPrec i 18 (concatD [prt 18 exp1, doc (showString "%"), prt 19 exp2])
+    EGMax _ exp -> prPrec i 19 (concatD [doc (showString "max"), prt 20 exp])
+    EGMin _ exp -> prPrec i 19 (concatD [doc (showString "min"), prt 20 exp])
+    ESum _ exp -> prPrec i 20 (concatD [doc (showString "sum"), prt 21 exp])
+    EProd _ exp -> prPrec i 20 (concatD [doc (showString "product"), prt 21 exp])
+    ECard _ exp -> prPrec i 20 (concatD [doc (showString "#"), prt 21 exp])
+    EMinExp _ exp -> prPrec i 20 (concatD [doc (showString "-"), prt 21 exp])
+    EDomain _ exp1 exp2 -> prPrec i 21 (concatD [prt 21 exp1, doc (showString "<:"), prt 22 exp2])
+    ERange _ exp1 exp2 -> prPrec i 22 (concatD [prt 22 exp1, doc (showString ":>"), prt 23 exp2])
+    EUnion _ exp1 exp2 -> prPrec i 23 (concatD [prt 23 exp1, doc (showString "++"), prt 24 exp2])
+    EUnionCom _ exp1 exp2 -> prPrec i 23 (concatD [prt 23 exp1, doc (showString ","), prt 24 exp2])
+    EDifference _ exp1 exp2 -> prPrec i 24 (concatD [prt 24 exp1, doc (showString "--"), prt 25 exp2])
+    EIntersection _ exp1 exp2 -> prPrec i 25 (concatD [prt 25 exp1, doc (showString "**"), prt 26 exp2])
+    EIntersectionDeprecated _ exp1 exp2 -> prPrec i 26 (concatD [prt 26 exp1, doc (showString "&"), prt 27 exp2])
+    EJoin _ exp1 exp2 -> prPrec i 26 (concatD [prt 26 exp1, doc (showString "."), prt 27 exp2])
+    ClaferId _ name -> prPrec i 27 (concatD [prt 0 name])
+    EInt _ posinteger -> prPrec i 27 (concatD [prt 0 posinteger])
+    EDouble _ posdouble -> prPrec i 27 (concatD [prt 0 posdouble])
+    EReal _ posreal -> prPrec i 27 (concatD [prt 0 posreal])
+    EStr _ posstring -> prPrec i 27 (concatD [prt 0 posstring])
   prtList _ [] = (concatD [])
   prtList _ (x:xs) = (concatD [prt 0 x, prt 0 xs])
+instance Print TransGuard where
+  prt i e = case e of
+    TransGuard _ exp -> prPrec i 0 (concatD [prt 1 exp])
+
+instance Print TransArrow where
+  prt i e = case e of
+    SyncTransArrow _ -> prPrec i 0 (concatD [doc (showString "-->>")])
+    GuardedSyncTransArrow _ transguard -> prPrec i 0 (concatD [doc (showString "-["), prt 0 transguard, doc (showString "]->>")])
+    NextTransArrow _ -> prPrec i 0 (concatD [doc (showString "-->")])
+    GuardedNextTransArrow _ transguard -> prPrec i 0 (concatD [doc (showString "-["), prt 0 transguard, doc (showString "]->")])
+
+instance Print PatternScope where
+  prt i e = case e of
+    PatScopeBefore _ exp -> prPrec i 0 (concatD [doc (showString "before"), prt 11 exp])
+    PatScopeAfter _ exp -> prPrec i 0 (concatD [doc (showString "after"), prt 11 exp])
+    PatScopeBetweenAnd _ exp1 exp2 -> prPrec i 0 (concatD [doc (showString "between"), prt 11 exp1, doc (showString "and"), prt 11 exp2])
+    PatScopeAfterUntil _ exp1 exp2 -> prPrec i 0 (concatD [doc (showString "after"), prt 11 exp1, doc (showString "until"), prt 11 exp2])
+    PatScopeEmpty _ -> prPrec i 0 (concatD [])
+
 instance Print Decl where
   prt i e = case e of
-    Decl _ locids exp -> prPrec i 0 (concatD [prt 0 locids, doc (showString ":"), prt 15 exp])
+    Decl _ locids exp -> prPrec i 0 (concatD [prt 0 locids, doc (showString ":"), prt 21 exp])
 
+instance Print VarBinding where
+  prt i e = case e of
+    VarBinding _ locid exp -> prPrec i 0 (concatD [prt 0 locid, doc (showString "="), prt 16 exp])
+
 instance Print Quant where
   prt i e = case e of
     QuantNo _ -> prPrec i 0 (concatD [doc (showString "no")])
@@ -291,3 +347,4 @@
     LocIdIdent _ posident -> prPrec i 0 (concatD [prt 0 posident])
   prtList _ [x] = (concatD [prt 0 x])
   prtList _ (x:xs) = (concatD [prt 0 x, doc (showString ";"), prt 0 xs])
+
diff --git a/src/Language/Clafer/Generator/Alloy.hs b/src/Language/Clafer/Generator/Alloy.hs
--- a/src/Language/Clafer/Generator/Alloy.hs
+++ b/src/Language/Clafer/Generator/Alloy.hs
@@ -20,19 +20,21 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
 -}
--- | Generates Alloy4.2 code for a Clafer model
+-- | Generates Alloy code for a Clafer model
 module Language.Clafer.Generator.Alloy (genModule) where
 
 import Control.Applicative
 import Control.Monad.State
 import Data.List
 import Data.Maybe
+import qualified Data.Map as Map
 import Prelude
 
 import Language.Clafer.Common
 import Language.Clafer.ClaferArgs
 import Language.Clafer.Front.AbsClafer
 import Language.Clafer.Front.LexClafer
+import Language.Clafer.Generator.AlloyLtl (bindSelf, selfIdent)
 import Language.Clafer.Generator.Concat
 import Language.Clafer.Intermediate.Intclafer hiding (exp)
 
@@ -79,7 +81,7 @@
 -- 07th Mayo 2012 Rafael Olaechea
 genDeclaration :: GenEnv -> IElement -> Concat
 genDeclaration genEnv x = case x of
-  IEClafer clafer'  -> (genClafer genEnv [] clafer') +++ (mkFact $ cconcat $ genSetUniquenessConstraint clafer')
+  IEClafer clafer'  -> (genClafer genEnv [] clafer') +++ (mkFact $ cconcat $ genSetUniquenessConstraint (uidIClaferMap genEnv) clafer')
   IEConstraint True pexp  -> mkFact $ genPExp genEnv [] pexp
   IEConstraint False pexp  -> mkAssert genEnv (genAssertName pexp) $ genPExp genEnv [] pexp
   IEGoal _ _ -> CString ""
@@ -89,7 +91,7 @@
 mkFact xs = cconcat [CString "fact ", mkSet xs, CString "\n"]
 
 genAssertName :: PExp -> Concat
-genAssertName    PExp{_inPos=(Span _ (Pos line _))} = CString $ "assertOnLine_" ++ show line
+genAssertName = CString . assertionName
 
 mkAssert :: GenEnv -> Concat -> Concat        -> Concat
 mkAssert    _         _         x@(CString "") = x
@@ -129,7 +131,14 @@
     )
   +++ CString "\n"
   +++ children'
+  +++ assertions
   where
+  -- this is a keyword that only signature facts bind, so an assertion names the instance
+  assertions = cconcat
+    [ mkAssert genEnv (genAssertName pexp) $ cconcat
+        [ CString $ "all " ++ selfIdent ++ " : " ++ _uid clafer' ++ " | "
+        , bindSelf $ genPExp genEnv (_uid clafer' : resPath) pexp ]
+    | IEConstraint False pexp <- _elements clafer' ]
   children' = cconcat $ filterNull $ map
              (genClafer genEnv ((_uid clafer') : resPath)) $
              getSubclafers $ _elements clafer'
@@ -198,8 +207,14 @@
 
 getTarget :: PExp -> PExp
 getTarget    x     = case x of
-  PExp _ _ _ (IFunExp op' (_:pexp:_))  -> if op' == iJoin then pexp else x
+  PExp _ _ _ (IFunExp op' (_:pexp:_)) | op' == iJoin -> pexp
+  -- a union of targets, e.g., Hub.p ++ fast: the union of their types (p + fast), since a field
+  -- declaration cannot name another signature's field
+  PExp _ _ _ e@(IFunExp op' ps) | op' == iUnion -> x{_exp = e{_exps = map (asTop . getTarget) ps}}
   _ -> x
+  where
+  asTop p@(PExp _ _ _ y@IClaferId{}) = p{_exp = y{_isTop = True}}
+  asTop p = p
 
 genType :: GenEnv -> PExp                              -> Concat
 genType    genEnv    x@(PExp _ _ _ y@(IClaferId _ _ _ _)) = genPExp genEnv []
@@ -237,33 +252,25 @@
   constraints = concatMap genConst $ _elements c
   genConst x = case x of
     IEConstraint True pexp  -> [ genPExp genEnv (_uid c : resPath) pexp ]
-    IEConstraint False pexp  -> [ CString "// Assertion " +++ (genAssertName pexp) +++ CString " ignored since nested assertions are not supported in Alloy.\n"]
+    IEConstraint False _  -> [] -- an assertion follows the signature, see genClafer
     IEClafer c' ->
         (if genCardCrude (_card c') `elem` ["one", "lone", "some"]
          then CString ""
          else mkCard ({- do not use the genRelName as the constraint name -} _uid c') False (genRelName $ _uid c') $ fromJust (_card c')
         )
         : (genParentSubrelationConstriant (uidIClaferMap genEnv) c')
-        : (genSetUniquenessConstraint c')
+        : (genSetUniquenessConstraint (uidIClaferMap genEnv) c')
     IEGoal _ _ -> error "[bug] Alloy.getConst: should not be given a goal." -- This should never happen
 
 
-genSetUniquenessConstraint :: IClafer -> [Concat]
-genSetUniquenessConstraint c =
-    (case _reference c of
-      Just (IReference True _) ->
-        (case _card c of
-            Just (lb,  ub) -> if (lb > 1 || ub > 1 || ub == -1)
-              then [ CString $ (
-                        (case isTopLevel c of
-                          False -> "all disj x, y : this.@" ++ (genRelName $ _uid c)
-                          True  -> " all disj x, y : "       ++ (_uid c)))
-                      ++ " | (x.@" ++ genRefName (_uid c) ++ ") != (y.@" ++ genRefName (_uid c) ++ ") "
-                   ]
-              else []
-            _ -> [])
-      _ -> []
-    )
+-- | The targets of the instances of a set reference under one parent are distinct (see
+--   'setReferenceKey'): a top-level clafer has the root as its parent.
+genSetUniquenessConstraint :: UIDIClaferMap -> IClafer -> [Concat]
+genSetUniquenessConstraint uidIClaferMap' c = case setReferenceKey uidIClaferMap' c of
+  Just s ->
+    [ CString $ (if isTopLevel c then " all disj x, y : " ++ _uid c else "all disj x, y : this.@" ++ genRelName (_uid c))
+        ++ " | (x.@" ++ genRefName (_uid s) ++ ") != (y.@" ++ genRefName (_uid s) ++ ") " ]
+  Nothing -> []
 
 genParentSubrelationConstriant :: UIDIClaferMap -> IClafer   -> Concat
 genParentSubrelationConstriant    uidIClaferMap'   headClafer =
@@ -422,20 +429,25 @@
 -- Generate code for logical expressions
 
 genPExp :: GenEnv -> [String] -> PExp -> Concat
-genPExp    genEnv    resPath     x     = genPExp' genEnv resPath $ adjustPExp resPath x
+genPExp    genEnv    resPath     x     = genPExp' genEnv resPath $ adjustPExp (uidIClaferMap genEnv) resPath x
 
 genPExp' :: GenEnv -> [String] -> PExp                      -> Concat
 genPExp'    genEnv    resPath     (PExp iType' pid' pos exp') = case exp' of
   IDeclPExp q d pexp -> Concat (IrPExp pid') $
     [ CString $ genQuant q, CString " "
     , cintercalate (CString ", ") $ map (genDecl genEnv resPath) d
-    , CString $ optBar d, genPExp' genEnv resPath pexp]
+    , CString $ optBar d, quantBody pexp]
     where
+    -- `some (c => a else b)`: without the parentheses, `some c` would be the condition
+    quantBody p@PExp{_exp = IFunExp op' _} | op' == iIfThenElse = brArg (genPExp' genEnv resPath) p
+    quantBody p = genPExp' genEnv resPath p
     optBar [] = ""
     optBar _  = " | "
   IClaferId _ "integer" _ _ -> CString "Int"
   IClaferId _ "int" _ _ -> CString "Int"
   IClaferId _ "string" _ _ -> CString "Int"
+  -- the empty set
+  IClaferId _ "noclafer" _ _ -> CString "none"
   IClaferId _ "dref" _ _ -> CString $ "@"  ++ getTClaferUID iType' ++ "_ref"
     where
       getTClaferUID (Just TMap{_so = TClafer{_hi = [u]}}) = u
@@ -446,6 +458,7 @@
         then sid
         else case iType' of
           Just TInteger -> vsident
+          Just TDecimal -> vsident
           Just TDouble -> vsident
           Just TReal -> vsident
           Just TString -> vsident
@@ -460,6 +473,7 @@
     exp'' = transformExp exp'
   IInt n -> CString $ show n
   IDouble _ -> error "no double numbers allowed"
+  IDecimal _ -> error "no decimal numbers allowed"
   IReal _ -> error "no real numbers allowed"
   IStr _ -> error "no strings allowed"
 
@@ -469,7 +483,8 @@
 -- Removed transfromation from x = -2 to x = (0-2) as this creates problem with  partial instances.
 -- See http://gsd.uwaterloo.ca:8888/question/461/new-translation-of-negative-number-x-into-0-x-is.
 transformExp :: IExp -> IExp
-transformExp (IFunExp op' (e1:_))
+-- Unary minus only: binary subtraction (iSub) is also "-".
+transformExp (IFunExp op' [e1])
   | op' == iMin = IFunExp iMul [PExp (_iType e1) "" noSpan $ IInt (-1), e1]
 transformExp    x@(IFunExp op' exps'@(e1:e2:_))
   | op' == iXor = IFunExp iNot [PExp (Just TBoolean) "" noSpan (IFunExp iIff exps')]
@@ -483,7 +498,7 @@
 genIFunExp    pid'      genEnv    resPath     (IFunExp "min" [exp']) = Concat (IrPExp pid') $ (CString "min[") : (genPExp' genEnv resPath exp') : [CString "]"]
 genIFunExp    pid'      genEnv    resPath     (IFunExp "max" [exp']) = Concat (IrPExp pid') $ (CString "max[") : (genPExp' genEnv resPath exp') : [CString "]"]
 -- ignore navigation from the root
-genIFunExp    pid'      genEnv    resPath     (IFunExp "."  [PExp{_exp=IClaferId{_sident="root"}}, exp2]) = genPExp' genEnv resPath exp2
+genIFunExp    _         genEnv    resPath     (IFunExp "."  [PExp{_exp=IClaferId{_sident="root"}}, exp2]) = genPExp' genEnv resPath exp2
 genIFunExp    pid'      genEnv    resPath     (IFunExp op' exps')
   | op' == iSumSet = genIFunExp pid' genEnv resPath (IFunExp iSumSet' [(removeright (head exps')), (getRight $ head exps')])
   | op' == iSumSet'  = Concat (IrPExp pid') $ intl exps'' (map CString $ genOp iSumSet)
@@ -538,34 +553,59 @@
 genOp op' = error $ "[bug] Alloy.genOp: Unmatched operator: " ++ op'
 
 -- adjust parent
-adjustPExp :: [String] -> PExp -> PExp
-adjustPExp resPath (PExp t pid' pos x) = PExp t pid' pos $ adjustIExp resPath x
+adjustPExp :: UIDIClaferMap -> [String] -> PExp -> PExp
+adjustPExp uidIClaferMap' resPath (PExp t pid' pos x) = PExp t pid' pos $ adjustIExp uidIClaferMap' resPath x
 
-adjustIExp :: [String] -> IExp -> IExp
-adjustIExp resPath x = case x of
-  IDeclPExp q d pexp -> IDeclPExp q d $ adjustPExp resPath pexp
+adjustIExp :: UIDIClaferMap -> [String] -> IExp -> IExp
+adjustIExp uidIClaferMap' resPath x = case x of
+  IDeclPExp q d pexp -> IDeclPExp q d $ adjustPExp uidIClaferMap' resPath pexp
   IFunExp op' exps' -> adjNav $ IFunExp op' $ map adjExps exps'
     where
     (adjNav, adjExps) = if op' == iJoin then (aNav, id)
-                        else (id, adjustPExp resPath)
+                        else (id, adjustPExp uidIClaferMap' resPath)
   IClaferId{} -> aNav x
   _  -> x
   where
-  aNav = fst.(adjustNav resPath)
+  aNav = fst.(adjustNav uidIClaferMap' resPath)
 
-adjustNav :: [String] -> IExp -> (IExp, [String])
-adjustNav resPath x@(IFunExp op' (pexp0:pexp:_))
+adjustNav :: UIDIClaferMap -> [String] -> IExp -> (IExp, [String])
+adjustNav uidIClaferMap' resPath x@(IFunExp op' (pexp0:pexp:_))
   | op' == iJoin = (IFunExp iJoin
                    [pexp0{_exp = iexp0},
                     pexp{_exp = iexp}], path')
   | otherwise   = (x, resPath)
   where
-  (iexp0, path) = adjustNav resPath (_exp pexp0)
-  (iexp, path') = adjustNav path    (_exp pexp)
-adjustNav resPath x@(IClaferId _ id' _ _)
-  | id' == parentIdent = (x{_sident = "~@" ++ (genRelName $ head resPath)}, tail resPath)
+  (iexp0, path) = adjustNav uidIClaferMap' resPath (_exp pexp0)
+  (iexp, path') = adjustNav uidIClaferMap' (typePath path) (_exp pexp)
+  -- the right operand navigates from the clafer of the left one, e.g., a variable @b1@ in @b1.parent@
+  typePath p = case _iType pexp0 of
+    Just (TClafer (uid':_)) | isJust (findIClafer uidIClaferMap' uid') -> claferPath uidIClaferMap' uid'
+    _ -> p
+adjustNav uidIClaferMap' resPath x@(IClaferId _ id' _ _)
+  | id' == parentIdent = (x{_sident = parentRel uidIClaferMap' $ head resPath}, tail resPath)
   | otherwise    = (x, resPath)
-adjustNav _ _ = error "Function adjustNav Expect a IFunExp or IClaferID as one of it's argument but it was given a differnt IExp" --This should never happen
+adjustNav _ _ _ = error "Function adjustNav Expect a IFunExp or IClaferID as one of it's argument but it was given a differnt IExp" --This should never happen
+
+-- | The UID of a clafer followed by the UIDs of its ancestors, without the root.
+claferPath :: UIDIClaferMap -> UID -> [UID]
+claferPath uidIClaferMap' uid' = uid' : case findIClafer uidIClaferMap' uid' of
+  Just c | _parentUID c /= rootIdent, isJust (findIClafer uidIClaferMap' $ _parentUID c) -> claferPath uidIClaferMap' $ _parentUID c
+  _ -> []
+
+-- | The inverse of the parent relation of the clafer with the given UID.
+-- A top-level abstract clafer has no parent relation; its parent is the parent
+-- of the instance in one of its nested subclafers.
+parentRel :: UIDIClaferMap -> UID -> String
+parentRel uidIClaferMap' uid' = case findIClafer uidIClaferMap' uid' of
+  Just c | isTopLevel c && _isAbstract c && not (null subRels)
+    -> "~(" ++ intercalate " + " (map ('@' :) subRels) ++ ")"
+  _ -> "~@" ++ genRelName uid'
+  where
+  subRels = [ genRelName $ _uid c'
+            | c' <- Map.elems uidIClaferMap'
+            , not $ isTopLevel c'
+            , _uid c' /= rootIdent
+            , uid' `elem` map _uid (tail $ findHierarchy getSuper uidIClaferMap' c') ]
 
 genQuant :: IQuant -> String
 genQuant    x       = case x of
diff --git a/src/Language/Clafer/Generator/AlloyLtl.hs b/src/Language/Clafer/Generator/AlloyLtl.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Clafer/Generator/AlloyLtl.hs
@@ -0,0 +1,807 @@
+{-# LANGUAGE RankNTypes, FlexibleContexts #-}
+{-
+ Copyright (C) 2012-2026 Kacper Bak, Jimmy Liang, Michal Antkiewicz, Rafael Olaechea <http://gsd.uwaterloo.ca>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-}
+{- | Generates Alloy 6 code with its native temporal logic for a dynamic Clafer model, one
+     with temporal operators or modifiers. The semantics follows Juodisius et al., Clafer:
+     Lightweight Modeling of Structure, Behaviour, and Variability (2019), section 5, with
+     two changes (an errata to the paper, which was never implemented):
+
+     * A trace is an infinite sequence of snapshots (Alloy's lasso traces).
+     * The signature of a clafer is the pool of all its instances over the trace. An instance
+       exists in a snapshot when its parent links it through the containment relation
+       @r_c@, which is @var@ unless the clafer is static (see 'isStatic'); @alive_c@ is the
+       set of the existing instances of @c@.
+     * An instance does not change its parent (the static field @p_c@), also when it
+       disappears and reappears, and nothing outlives its parent. A scope bounds the instances
+       of a clafer over the trace, not in a snapshot.
+     * Change: an instance may reappear. The paper forbids it, but then a cyclic behaviour,
+       e.g., green, yellow, red, green, ..., needs infinitely many instances, which no lasso
+       trace over finitely many atoms has.
+     * The multiplicities, group cardinalities and constraints of a clafer hold in every
+       snapshot, for every existing instance; the top-level ones hold in every snapshot.
+     * Change: the temporal obligations of a constraint (X, F, G and U, Alloy's @after@,
+       @eventually@, @always@ and @until@) hold while the parent of the context instance
+       exists; the paper does not bound them. So @[ req=down --> movingDown ]@ in the state
+       @movingUp@ takes the machine to @movingDown@, and the pending obligations of nested
+       states lapse when their enclosing state is left. A modeller extends the timeline of
+       a constraint by placing it higher in the hierarchy, or at the top level. A transition
+       of a clafer, e.g., @on --> off@, is a constraint of the clafer.
+     * The negations are pushed inside the temporal operators first (see 'pushNegations'),
+       so a negated obligation lapses with the parent too: @!(F error)@ is @G !error@.
+     * @initial@ children exist whenever their parent appears; the instances of a @final@
+       clafer do not change while their parent exists.
+     * @initially@ and @finally@ refer to the first and the last snapshot of the context
+       instance's lifetime.
+-}
+module Language.Clafer.Generator.AlloyLtl (genAlloyLtlModule, bindSelf, selfIdent) where
+
+import Control.Monad.State
+import Data.Char (isAlphaNum)
+import Data.List
+import Data.Maybe
+import Prelude
+
+import Language.Clafer.Common
+import Language.Clafer.ClaferArgs
+import Language.Clafer.Front.AbsClafer hiding (FinalRef, FinalTarget)
+import Language.Clafer.Front.LexClafer
+import Language.Clafer.Generator.Concat
+import Language.Clafer.Intermediate.Intclafer hiding (exp)
+
+data GenEnv = GenEnv
+  { claferargs :: ClaferArgs
+  , uidIClaferMap :: UIDIClaferMap
+  , allClafers :: [IClafer]   -- ^ the clafers of the model, without the root
+  , forScopes :: String
+  , contextInstance :: String  -- ^ the context instance, @this@ unless in the value of an initializer
+  }
+
+-- | Alloy 6 code generation
+genAlloyLtlModule :: ClaferArgs -> (IModule, GEnv) -> [(UID, Integer)] -> [Token]     -> (Result, [(Span, IrTrace)])
+genAlloyLtlModule    claferargs'   (imodule, genv)    scopes              otherTokens' = (flatten output, filter ((/= NoTrace) . snd) $ mapLineCol output)
+  where
+  uidIClaferMap' = uidClaferMap genv
+  -- the clafers of the module, as the optimizer left them: the map of the environment still has
+  -- the abstract clafers that no concrete clafer extends, which the optimizer removed
+  root = (fromMaybe (error "AlloyLtl: missing root clafer") $ findIClafer uidIClaferMap' rootIdent)
+           { _elements = _mDecls imodule }
+  clafers' = tail $ nestedClafers root
+  tl = trace_len claferargs'
+  genEnv = GenEnv claferargs' uidIClaferMap' clafers' forScopes' "this"
+
+  -- a scope bounds the instance identities across the trace, which may be reused when an
+  -- instance reappears; the multiplicities bound the existing instances in each snapshot
+  forScopes' = "for 1 but " ++ intercalate ", " (map (\(uid', scope') -> show scope' ++ " " ++ uid') scopes ++ [show tl ++ " steps"])
+  output = header genEnv otherTokens' +++ cconcat (map (genClafer genEnv) $ root : clafers')
+
+nestedClafers :: IClafer -> [IClafer]
+nestedClafers c = c : concatMap nestedClafers (getSubclafers $ _elements c)
+
+header :: GenEnv -> [Token]     -> Concat
+header    genEnv    otherTokens' = CString $ unlines
+    [ "open util/integer"
+    , genAlloyEscapes otherTokens' ++ "pred show {}"
+    , if validate $ claferargs genEnv
+      then ""
+      else "run show " ++ forScopes genEnv
+    , ""]
+
+genAlloyEscapes :: [Token]  -> String
+genAlloyEscapes otherTokens' = concatMap printAlloyEscape otherTokens'
+    where
+      printAlloyEscape (PT _ (T_PosAlloy code)) =  let
+          code' = fromJust $ stripPrefix "[alloy|" code
+        in
+          take (length code' - 2) code' ++ "\n"
+      printAlloyEscape _                        = ""
+
+-- -----------------------------------------------------------------------------
+-- the structure of the model
+
+isRoot :: IClafer -> Bool
+isRoot c = _uid c == rootIdent
+
+-- | The parent of the clafer, the root for the top-level ones.
+parentOf :: GenEnv -> IClafer -> Maybe IClafer
+parentOf genEnv c
+  | isRoot c     = Nothing
+  | isTopLevel c = findIClafer (uidIClaferMap genEnv) rootIdent
+  | otherwise    = findIClafer (uidIClaferMap genEnv) $ _parentUID c
+
+-- | A top-level abstract clafer has no containment relation; its instances are those of its subclafers.
+hasContainment :: IClafer -> Bool
+hasContainment c = not (isRoot c) && not (_isAbstract c && isTopLevel c)
+
+-- | The children that the clafer contains through a containment relation.
+containedClafers :: IClafer -> [IClafer]
+containedClafers = filter hasContainment . getSubclafers . _elements
+
+-- | Whether the containment relation of the clafer is static: the clafer is final and so
+--   are its ancestors, so its instances exist in the whole trace (Juodisius et al., 6.2).
+isStatic :: GenEnv -> IClafer -> Bool
+isStatic genEnv c
+  | isRoot c  = True
+  | otherwise = _isFinal c && maybe True (isStatic genEnv) (parentOf genEnv c)
+
+-- | The nearest super clafer that declares a reference, and the reference.
+inheritedReference :: GenEnv -> IClafer -> Maybe (IClafer, IReference)
+inheritedReference genEnv c = listToMaybe
+  [ (s, r) | s <- tail $ findHierarchy getSuper (uidIClaferMap genEnv) c, Just r <- [_reference s] ]
+
+-- | The direct subclafers of the clafer.
+subsOf :: GenEnv -> IClafer -> [IClafer]
+subsOf genEnv c = [ c' | c' <- allClafers genEnv, getSuper c' == [_uid c] ]
+
+-- | The concrete clafers that are or extend the clafer.
+concreteSubs :: GenEnv -> IClafer -> [IClafer]
+concreteSubs genEnv c
+  | _isAbstract c = concatMap (concreteSubs genEnv) $ subsOf genEnv c
+  | otherwise     = [c]
+
+aliveName :: UID -> String
+aliveName uid'
+  | uid' == rootIdent = rootIdent
+  | otherwise         = "alive_" ++ uid'
+
+genRelName :: String -> String
+genRelName name = "r_" ++ name
+
+genRefName :: String -> String
+genRefName name = name ++ "_ref"
+
+genParentName :: String -> String
+genParentName name = "p_" ++ name
+
+-- | The relation from the instances of the clafer to their existing parents. The parent of an
+--   instance does not change, so the navigation also works after the instance disappeared.
+--   An abstract clafer's instances are those of its concrete subclafers, which may have
+--   other parents, e.g., the subclafers of a top-level abstract clafer.
+parentRel :: GenEnv -> UID -> String
+parentRel genEnv uid' = case findIClafer (uidIClaferMap genEnv) uid' of
+  Just c -> case map rel $ concreteSubs genEnv c of
+    []    -> "(none->none)"
+    [r]   -> r
+    rels' -> "(" ++ intercalate " + " rels' ++ ")"
+  Nothing -> error $ "AlloyLtl.parentRel: clafer not found: " ++ uid'
+  where
+  rel c = "(@" ++ genParentName (_uid c) ++ " :> " ++ maybe rootIdent (aliveName . _uid) (parentOf genEnv c) ++ ")"
+
+-- | The relation from the instances of the clafer to their parents, also those that do not exist:
+--   the parent of an instance does not change.
+fixedParentRel :: GenEnv -> IClafer -> String
+fixedParentRel genEnv c = case map (("@" ++) . genParentName . _uid) $ concreteSubs genEnv c of
+  []    -> "(none->none)"
+  [r]   -> "(" ++ r ++ ")"
+  rels' -> "(" ++ intercalate " + " rels' ++ ")"
+
+mkFact :: Concat -> Concat
+mkFact x@(CString "") = x
+mkFact xs = cconcat [CString "fact ", mkSet xs, CString "\n"]
+
+mkSet :: Concat -> Concat
+mkSet xs = cconcat [CString "{ ", xs, CString " }"]
+
+showSet :: Concat -> [Concat] -> Concat
+showSet delim xs = showSet' delim $ filterNull xs
+  where
+  showSet' _ []     = CString "{}"
+  showSet' delim' xs' = mkSet $ cintercalate delim' xs'
+
+optShowSet :: [Concat] -> Concat
+optShowSet [] = CString ""
+optShowSet xs = CString "\n" +++ showSet (CString "\n  ") xs
+
+genClafer :: GenEnv -> IClafer -> Concat
+genClafer genEnv c = cunlines (filterNull
+  [ claferDecl c (showSet (CString "\n, ") (genRelations genEnv c) +++ optShowSet (filterNull $ genConstraints genEnv c))
+  , if isRoot c then CString "" else aliveFun
+  , mkFact $ cintercalate (CString "\n  ") $ filterNull $ genStructure genEnv c
+  , cunlines $ genFacts genEnv c
+  , cconcat $ map (mkAssert genEnv c) $ getAssertions c
+  ]) +++ CString "\n"
+  where
+  aliveFun = CString $ "fun " ++ aliveName (_uid c) ++ " : set " ++ _uid c ++ " { " ++ aliveBody ++ " }"
+  aliveBody
+    | hasContainment c = sigOf (fromJust $ parentOf genEnv c) ++ ".@" ++ genRelName (_uid c)
+    | otherwise        = case map (aliveName . _uid) $ subsOf genEnv c of
+        []    -> "none"
+        alive -> intercalate " + " alive
+  sigOf p = if isRoot p then rootIdent else _uid p
+
+claferDecl :: IClafer -> Concat -> Concat
+claferDecl    c     rest    = cconcat
+  [ CString $ if isRoot c then "one " else ""
+  , CString $ if _isAbstract c then "abstract " else ""
+  , CString "sig "
+  , Concat NoTrace [CString $ _uid c, genExtends $ _super c, CString "\n", rest]
+  ]
+  where
+  genExtends (Just (PExp _ _ _ (IClaferId _ i _ _))) = CString " " +++ Concat NoTrace [CString $ "extends " ++ i]
+  genExtends _ = CString ""
+
+-- | The parent, reference and containment fields of the clafer.
+genRelations :: GenEnv -> IClafer -> [Concat]
+genRelations genEnv c = parent' ++ reference' ++ map mkRel (containedClafers c)
+  where
+  parent'
+    | hasContainment c && not (_isAbstract c) =
+        [CString $ genParentName (_uid c) ++ " : lone " ++ maybe rootIdent sigName (parentOf genEnv c)]
+    | otherwise = []
+  sigName p = if isRoot p then rootIdent else _uid p
+  reference' = case _reference c of
+    Just r  -> [CString $ var' (isStatic genEnv c && not (null (_refModifiers r))) ++ genRefName (_uid c) ++ " : set " ++ refType genEnv c]
+    Nothing -> []
+  mkRel c' = Concat NoTrace [CString $ var' (isStatic genEnv c') ++ genRelName (_uid c') ++ " : set " ++ _uid c']
+  var' static = if static then "" else "var "
+
+refType :: GenEnv -> IClafer -> String
+refType genEnv c = maybe "" (targetType . _ref) $ _reference c
+  where
+  targetType pexp = case getTarget pexp of
+    PExp _ _ _ (IClaferId _ sid _ _) | isPrimitive sid -> "Int"
+                                     | otherwise       -> sid
+    -- a union of targets, e.g., Hub.p ++ fast: the union of their signatures (p + fast), since a
+    -- field declaration cannot name another signature's field
+    PExp _ _ _ (IFunExp op' ps) | op' == iUnion -> intercalate " + " $ map targetType ps
+    target -> flatten $ genPExp genEnv [_uid c] target
+
+getTarget :: PExp -> PExp
+getTarget    x     = case x of
+  PExp _ _ _ (IFunExp op' (_:pexp:_))  -> if op' == iJoin then pexp else x
+  _ -> x
+
+-- | The facts about the instances of the clafer: a fixed parent, which exists; for a nested
+--   abstract clafer, its instances are those of its subclafers.
+genStructure :: GenEnv -> IClafer -> [Concat]
+genStructure genEnv c
+  | not (hasContainment c) = []
+  | _isAbstract c =
+      [ CString $ "always @" ++ rel ++ " = " ++ case map (('@' :) . genRelName . _uid) $ subsOf genEnv c of
+          []   -> "none->none"
+          rels -> "(" ++ intercalate " + " rels ++ ")" ]
+  | otherwise =
+      [ CString $ "always ~@" ++ rel ++ " in @" ++ genParentName (_uid c)
+      , if isRoot parent' then CString "" else CString $ "always @" ++ rel ++ ".univ in " ++ aliveName (_uid parent')
+      ]
+  where
+  rel = genRelName $ _uid c
+  parent' = fromJust $ parentOf genEnv c
+
+-- | The constraints in the signature fact of the clafer, which hold for every existing instance.
+genConstraints :: GenEnv -> IClafer -> [Concat]
+genConstraints genEnv c = map always' (filterNull $ refConsts ++ groupConst ++ childConsts) ++ absentConsts ++ initialConsts ++ finalConsts
+  where
+  uid' = _uid c
+  alive = aliveName uid'
+  -- in every snapshot in which this instance exists
+  always' x
+    | isRoot c  = cconcat [CString "always (", x, CString ")"]
+    | otherwise = cconcat [CString "always (this in ", CString alive, CString " implies (", x, CString "))"]
+  -- an instance refers to one existing target
+  refConsts = case _reference c of
+    Just _ ->
+      [ CString $ "one this.@" ++ genRefName uid' ] ++
+      [ CString $ "this.@" ++ genRefName uid' ++ " in " ++ aliveName target
+      | let target = refType genEnv c, target /= "Int", isJust (findIClafer (uidIClaferMap genEnv) target) ] ++
+      -- a reference that refines an inherited one is the same reference, seen through the
+      -- subclafer: an instance has one target (gsdlab/clafer#120)
+      [ CString $ "this.@" ++ genRefName uid' ++ " in this.@" ++ genRefName (_uid s)
+      | Just (s, _) <- [inheritedReference genEnv c] ]
+    Nothing -> []
+  -- an instance has a reference only while it exists, as it has children only while it exists:
+  -- a state is an instance of the model, so an obligation on the value of an instance that does
+  -- not exist fails (kbak/clafer-semantics#168, reading A; gsdlab/clafer#122)
+  absentConsts =
+    [ CString $ "always (this not in " ++ alive ++ " implies no this.@" ++ genRefName uid' ++ ")"
+    | not (isRoot c), Just _ <- [_reference c] ]
+  groupConst = [ genGroupConst genEnv c ]
+  childConsts = concatMap childConst $ containedClafers c
+  childConst c' = genParentSubrelationConstraint (uidIClaferMap genEnv) c' : genSetUniquenessConstraint genEnv c'
+  -- whenever this instance appears
+  initialConsts =
+    [ appears $ CString $ "some this.@" ++ genRelName (_uid c') | c' <- containedClafers c, _isInitial c' ]
+  appears x
+    | isRoot c  = x
+    | otherwise = cconcat [CString "always (this in ", CString alive, CString " and not before this in ", CString alive, CString " implies (", x, CString "))"]
+  -- the relation does not change while this instance exists
+  stable x
+    | isRoot c  = CString $ "always ((" ++ x ++ ")' = " ++ x ++ ")"
+    | otherwise = CString $ "always (this in " ++ alive ++ " and after this in " ++ alive ++ " implies (" ++ x ++ ")' = " ++ x ++ ")"
+  -- final and finalref fix the target of each instance, finaltarget only the set of targets
+  fixesEach s r = _isFinal s || any (`elem` [FinalRefTarget, FinalRef]) (_refModifiers r)
+  finalConsts =
+    -- the instances of a final child do not change while this instance exists
+    [ stable $ "this.@" ++ genRelName (_uid c') | c' <- containedClafers c, _isFinal c', not (isStatic genEnv c') ] ++
+    [ stable $ "this.@" ++ genRefName uid' | Just r <- [_reference c], fixesEach c r, not (isStatic genEnv c) ] ++
+    -- `final motor : engine` or `finalref motor : engine` fixes the reference that motor inherits
+    -- from engine, unless engine's modifier fixes it already (#109)
+    [ stable $ "this.@" ++ genRefName (_uid sup)
+    | Nothing <- [_reference c], _isFinal c || FinalRef `elem` _finalReferences (_modifiers c)
+    , Just (sup, r) <- [inheritedReference genEnv c], not (fixesEach sup r) ] ++
+    -- a finaltarget child points to the same set of targets while this instance exists; its
+    -- instances may change and swap their targets
+    [ stable $ "this.@" ++ genRelName (_uid c') ++ ".@" ++ refRel | c' <- containedClafers c, Just refRel <- [finalTargetRef c'] ]
+  finalTargetRef c' = case _reference c' of
+    Just r | FinalTarget `elem` _refModifiers r, not (isStatic genEnv c') -> Just $ genRefName (_uid c')
+    Just _ -> Nothing
+    Nothing
+      | FinalTarget `elem` _finalReferences (_modifiers c'), not (isStatic genEnv c') -> genRefName . _uid . fst <$> inheritedReference genEnv c'
+      | otherwise -> Nothing
+
+-- | The constraints of the clafer and the cardinalities of its children, each a fact of its own,
+--   which holds for every existing instance: an unsat core gives these, which are removed to find
+--   a near-miss example. Alloy gives the unsat core of the temporal formulas of a signature fact
+--   for the whole fact, so they are not in the signature fact. The bounds of an interval are two
+--   facts, which are removed one by one.
+genFacts :: GenEnv -> IClafer -> [Concat]
+genFacts genEnv c = map fact $ concatMap childCards (containedClafers c) ++ userFacts
+  where
+  uid' = _uid c
+  userFacts = [ (IrPExp $ _pid pexp, genPExp genEnv [uid'] pexp) | IEConstraint True pexp <- _elements c ]
+  childCards c' = case fromJust $ _card c' of
+    (1, 1)  -> [(ExactCard child False, CString $ "one " ++ rel)]
+    (0, 1)  -> [(ExactCard child False, CString $ "lone " ++ rel)]
+    (1, -1) -> [(ExactCard child False, CString $ "some " ++ rel)]
+    (n, m)  -> [ (LowerCard child False, CString $ show n ++ " <= #(" ++ rel ++ ")") | n > 0 ] ++
+               [ (UpperCard child False, CString $ "#(" ++ rel ++ ") <= " ++ show m) | m /= -1 ]
+    where
+    child = _uid c'
+    rel = "this.@" ++ genRelName child
+  -- the constraint, for every instance in every snapshot in which it exists
+  fact (trace, x) = cconcat
+    [ CString "fact { "
+    , Concat trace [forEveryInstance c x]
+    , CString " }" ]
+
+-- | The constraint for every instance of the clafer, in every snapshot in which it exists. The
+--   root has one instance, root itself, which this is in a top-level constraint: a quantified
+--   variable would mostly be unused, which Alloy warns about.
+forEveryInstance :: IClafer -> Concat -> Concat
+forEveryInstance c x
+  | isRoot c  = bindTo rootIdent $ cconcat [CString "always (", x, CString ")"]
+  | otherwise = cconcat [CString $ "all " ++ selfIdent ++ " : " ++ uid' ++ " | ", bindSelf always']
+  where
+  uid' = _uid c
+  always' = cconcat [CString $ "always (" ++ selfIdent ++ " in " ++ aliveName uid' ++ " implies (", x, CString "))"]
+
+-- | The variable of the instance in a fact: this is a keyword, which only signature facts bind.
+selfIdent :: String
+selfIdent = "self_"
+
+-- | The constraint for the instance bound to 'selfIdent' instead of this.
+bindSelf :: Concat -> Concat
+bindSelf = bindTo selfIdent
+
+-- | The constraint with this replaced by the given name.
+bindTo :: String -> Concat -> Concat
+bindTo ident (CString str) = CString $ bind Nothing str
+  where
+  bind prev ('t':'h':'i':'s':rest)
+    | maybe True (not . identChar) prev && not (startsIdent rest) = ident ++ bind (Just '_') rest
+  bind _ (x:xs) = x : bind (Just x) xs
+  bind _ [] = []
+  startsIdent (x:_) = identChar x
+  startsIdent [] = False
+  identChar x = isAlphaNum x || x == '_' || x == '\''
+bindTo ident (Concat trace xs) = Concat trace $ map (bindTo ident) xs
+
+getAssertions :: IClafer -> [PExp]
+getAssertions c = [ pexp | IEConstraint False pexp <- _elements c ]
+
+mkAssert :: GenEnv -> IClafer -> PExp -> Concat
+mkAssert genEnv c pexp = cconcat
+  [ CString "assert ", name, CString " { ", forEveryInstance c $ genPExp genEnv [_uid c] pexp, CString " }\n"
+  , CString "check ", name, CString " ", CString $ forScopes genEnv, CString "\n\n"
+  ]
+  where
+  name = CString $ assertionName pexp
+
+-- | The targets of the instances of a set reference under one parent are distinct (see
+--   'setReferenceKey').
+genSetUniquenessConstraint :: GenEnv -> IClafer -> [Concat]
+genSetUniquenessConstraint genEnv c = case setReferenceKey (uidIClaferMap genEnv) c of
+  Just s -> [ CString $ "all disj x, y : this.@" ++ genRelName (_uid c) ++ " | (x.@" ++ genRefName (_uid s) ++ ") != (y.@" ++ genRefName (_uid s) ++ ")" ]
+  Nothing -> []
+
+genParentSubrelationConstraint :: UIDIClaferMap -> IClafer -> Concat
+genParentSubrelationConstraint uidIClaferMap' headClafer = case matchNestedInheritance uidIClaferMap' headClafer of
+  Just match@NestedInheritanceMatch{ _superClafer = superClafer }
+    | isProperNesting uidIClaferMap' (Just match) && not (isTopLevel superClafer) ->
+        CString $ "this.@" ++ genRelName (_uid headClafer) ++ " in this.@" ++ genRelName (_uid superClafer)
+  _ -> CString ""
+
+genGroupConst :: GenEnv -> IClafer -> Concat
+genGroupConst genEnv clafer'
+  | _isAbstract clafer' || null children' || flatten card' == "" = CString ""
+  | otherwise = cconcat [CString "let children = ", brArg id $ CString children', CString " | ", card']
+  where
+  superHierarchy = findHierarchy getSuper (uidIClaferMap genEnv) clafer'
+  children' = intercalate " + " $ map (("this.@" ++) . genRelName . _uid) $ getSubclafers $ concatMap _elements superHierarchy
+  card' = mkCard (_uid clafer') True "children" $ _interval $ fromJust $ _gcard clafer'
+
+mkCard :: String -> Bool -> String -> (Integer, Integer) -> Concat
+mkCard constraintName group' element' crd
+  | crd' == "set" || crd' == ""        = CString ""
+  | crd' `elem` ["one", "lone", "some"] = CString $ crd' ++ " " ++ element'
+  | otherwise                            = interval'
+  where
+  interval' = genInterval constraintName group' element' crd
+  crd'  = flatten interval'
+
+genInterval :: String -> Bool -> String -> Interval -> Concat
+genInterval constraintName group' element' x = case x of
+  (1, 1)  -> cardConcat constraintName group' [CString "one"]
+  (0, 1)  -> cardConcat constraintName group' [CString "lone"]
+  (1, -1) -> cardConcat constraintName group' [CString "some"]
+  (0, -1) -> CString "set"
+  (n, exinteger) ->
+    case (s1, s2) of
+      (Just c1, Just c2) -> cconcat [c1, CString " and ", c2]
+      (Just c1, Nothing) -> c1
+      (Nothing, Just c2) -> c2
+      (Nothing, Nothing) -> undefined
+    where
+    element'' = "(" ++ element' ++ ")"
+    s1 = if n == 0 then Nothing else Just $ cardLowerConcat constraintName group' [CString $ show n ++ " <= #" ++ element'']
+    s2 = cardUpperConcat constraintName group' . (: []) . CString <$> genExInteger element'' x exinteger
+
+cardConcat :: String -> Bool -> [Concat] -> Concat
+cardConcat constraintName = Concat . ExactCard constraintName
+
+cardLowerConcat :: String -> Bool -> [Concat] -> Concat
+cardLowerConcat constraintName = Concat . LowerCard constraintName
+
+cardUpperConcat :: String -> Bool -> [Concat] -> Concat
+cardUpperConcat constraintName = Concat . UpperCard constraintName
+
+genExInteger :: String -> Interval -> Integer -> Maybe Result
+genExInteger element' (y, z) x
+  | y == 0 && z == 0 = Just $ "#" ++ element' ++ " = 0"
+  | x == -1          = Nothing
+  | otherwise        = Just $ "#" ++ element' ++ " <= " ++ show x
+
+-- -----------------------------------------------------------------------------
+-- expressions; the head of the path is the UID of the context clafer
+
+genPExp :: GenEnv -> [String] -> PExp -> Concat
+genPExp genEnv resPath x = genPExp' genEnv resPath $ adjustPExp genEnv resPath $ pushNegations True x
+
+-- | Pushes the negations of the formulas with temporal operators to the formulas without them,
+--   with the dualities of LTL (@!F a@ is @G !a@, @!X a@ is @X !a@, @!(a U b)@ is @!b W (!a && !b)@).
+--   The obligations are bounded by the parent's lifetime afterwards, so an obligation lapses with
+--   the parent also when it is negated: @!(F error)@ means @G !error@, and lets the parent
+--   disappear. @initially@ and @finally@ anchor their negation: @!initially a@ is @initially !a@.
+--   A formula and its negation may both hold, on a lifetime that ends before their obligations.
+--   The polarity is @True@ for the formula itself, @False@ for its negation. @one@ and @lone@
+--   keep the classical negation.
+pushNegations :: Bool -> PExp -> PExp
+pushNegations pos' x@(PExp t pid' sp e)
+  | not $ hasTemporal x = if pos' then x else neg x
+  | otherwise = case e of
+    IFunExp op' [a]
+      | op' == iNot -> pushNegations (not pos') a
+      | op' == iF   -> mk (if pos' then iF else iG) [push a]
+      | op' == iG   -> mk (if pos' then iG else iF) [push a]
+      | op' `elem` [iX, iInitially, iFinally] -> mk op' [push a]
+    IFunExp op' [a, b]
+      | op' == iAnd  -> mk (if pos' then iAnd else iOr) [push a, push b]
+      | op' == iOr   -> mk (if pos' then iOr else iAnd) [push a, push b]
+      | op' == iImpl, pos', not (hasTemporal a) -> mk iImpl [a, push b]
+      | op' == iImpl -> mk (if pos' then iOr else iAnd) [pushNegations (not pos') a, push b]
+      | op' == iIff  -> pushNegations pos' $ bool iAnd [bool iImpl [a, b], bool iImpl [b, a]]
+      | op' == iXor  -> pushNegations pos' $ bool iOr [bool iAnd [a, bool iNot [b]], bool iAnd [bool iNot [a], b]]
+      | op' `elem` [iU, iW], pos' -> mk op' [push a, push b]
+      | op' `elem` [iU, iW] -> mk (if op' == iU then iW else iU) [push b, mk iAnd [push a, push b]]
+    IFunExp op' [c, a, b]
+      | op' == iIfThenElse, t == Just TBoolean, not (hasTemporal c) -> mk op' [c, push a, push b]
+      | op' == iIfThenElse, t == Just TBoolean ->
+          pushNegations pos' $ bool iAnd [bool iImpl [c, a], bool iImpl [bool iNot [c], b]]
+    IDeclPExp q ds@(_:_) body
+      | q == IAll -> PExp t pid' sp $ IDeclPExp (if pos' then IAll else ISome) ds $ push body
+      | q == ISome -> PExp t pid' sp $ IDeclPExp (if pos' then ISome else IAll) ds $ push body
+      | q == INo -> PExp t pid' sp $ IDeclPExp (if pos' then IAll else ISome) ds $ pushNegations (not pos') body
+    _ -> if pos' then x else neg x
+  where
+  push = pushNegations pos'
+  mk op' = PExp t pid' sp . IFunExp op'
+  bool op' = PExp (Just TBoolean) pid' sp . IFunExp op'
+  neg a = bool iNot [a]
+
+-- | Whether the formula has temporal operators.
+hasTemporal :: PExp -> Bool
+hasTemporal (PExp _ _ _ e) = case e of
+  IFunExp op' es -> op' `elem` (iFinally : ltlOps) || any hasTemporal es
+  IDeclPExp _ _ body -> hasTemporal body
+  _ -> False
+
+genPExp' :: GenEnv -> [String] -> PExp                      -> Concat
+genPExp'    genEnv    resPath     (PExp iType' pid' pos exp') = case exp' of
+  IDeclPExp q d pexp -> Concat (IrPExp pid')
+    [ CString $ genQuant q, CString " "
+    , cintercalate (CString ", ") $ map (genDecl genEnv resPath) d
+    , CString $ optBar d, genPExp' genEnv resPath pexp]
+    where
+    optBar [] = ""
+    optBar _  = " | "
+  IClaferId _ "integer" _ _ -> CString "Int"
+  IClaferId _ "int" _ _ -> CString "Int"
+  IClaferId _ "string" _ _ -> CString "Int"
+  -- the empty set
+  IClaferId _ "noclafer" _ _ -> CString "none"
+  IClaferId _ "dref" _ _ -> CString $ "@" ++ genRefName (getTClaferUID iType')
+    where
+      getTClaferUID (Just TMap{_so = TClafer{_hi = (u:_)}}) = u
+      getTClaferUID t = error $ "[bug] AlloyLtl.genPExp'.getTClaferUID: unknown type: " ++ show t
+  -- a variable of a quantifier
+  IClaferId _ sid _ (LocalBind _) -> CString sid
+  IClaferId _ sid istop _ -> CString $
+      if head sid `elem` "~@("
+        then sid
+        else case iType' of
+          Just TInteger -> vsident
+          Just TDecimal -> vsident
+          Just TDouble -> vsident
+          Just TReal -> vsident
+          Just TString -> vsident
+          _ -> sid'
+    where
+    sid'
+      | sid == thisIdent = thisAlive genEnv resPath
+      | sid == rootIdent = rootIdent
+      | istop            = aliveName sid
+      | otherwise        = '@' : genRelName sid
+    vsident = sid' ++ ".@" ++ genRefName (if sid == thisIdent then head resPath else sid)
+  IFunExp _ _ -> case exp'' of
+    IFunExp _ _ -> genIFunExp pid' genEnv resPath exp''
+    _ -> genPExp' genEnv resPath $ PExp iType' pid' pos exp''
+    where
+    exp'' = transformExp exp'
+  IInt n -> CString $ show n
+  IDouble _ -> error "no double numbers allowed"
+  IDecimal _ -> error "no decimal numbers allowed"
+  IReal _ -> error "no real numbers allowed"
+  IStr _ -> error "no strings allowed"
+
+-- | The context instance, as long as it exists.
+thisAlive :: GenEnv -> [String] -> String
+thisAlive genEnv (ctx:_) | ctx /= rootIdent = "(" ++ contextInstance genEnv ++ " & " ++ aliveName ctx ++ ")"
+thisAlive _ _ = rootIdent
+
+-- | Whether the parent of the context instance exists, unless the parent is the root, which
+--   always exists. The obligations of a constraint last as long as the parent.
+parentExists :: GenEnv -> [String] -> Maybe String
+parentExists genEnv (ctx:_)
+  | Just c <- findIClafer (uidIClaferMap genEnv) ctx
+  , any (maybe False (not . isRoot) . parentOf genEnv) $ concreteSubs genEnv c
+  = Just $ "some " ++ contextInstance genEnv ++ "." ++ parentRel genEnv ctx
+parentExists _ _ = Nothing
+
+-- | Whether the context instance appears now (its first snapshot), or the trace begins.
+appearsNow :: GenEnv -> [String] -> String
+appearsNow genEnv (ctx:_) | ctx /= rootIdent = "not before " ++ contextInstance genEnv ++ " in " ++ aliveName ctx
+appearsNow _ _ = "not before some " ++ rootIdent
+
+-- 3-May-2012 Rafael Olaechea.
+-- Removed transfromation from x = -2 to x = (0-2) as this creates problem with  partial instances.
+-- See http://gsd.uwaterloo.ca:8888/question/461/new-translation-of-negative-number-x-into-0-x-is.
+-- Weak until: a W b === G a || a U b
+transformExp :: IExp -> IExp
+transformExp (IFunExp op' [e1])
+  | op' == iMin = IFunExp iMul [PExp (_iType e1) "" noSpan $ IInt (-1), e1]
+transformExp    x@(IFunExp op' exps'@(e1:e2:_))
+  | op' == iXor = IFunExp iNot [PExp (Just TBoolean) "" noSpan (IFunExp iIff exps')]
+  | op' == iW = IFunExp iOr [PExp (Just TBoolean) "" noSpan $ IFunExp iG [e1], PExp (Just TBoolean) "" noSpan x{_op = iU}]
+  | op' == iJoin && isClaferName' e1 && isClaferName' e2 &&
+    getClaferName e1 == thisIdent && head (getClaferName e2) == '~' =
+        IFunExp op' [e1{_iType = Just $ TClafer []}, e2]
+  | otherwise  = x
+transformExp x = x
+
+genIFunExp :: String -> GenEnv -> [String] -> IExp                  -> Concat
+genIFunExp    pid'      genEnv    resPath     (IFunExp "min" [exp']) = Concat (IrPExp pid') [CString "min[", genPExp' genEnv resPath exp', CString "]"]
+genIFunExp    pid'      genEnv    resPath     (IFunExp "max" [exp']) = Concat (IrPExp pid') [CString "max[", genPExp' genEnv resPath exp', CString "]"]
+-- the navigation starts from the context instance, also after it has disappeared
+genIFunExp    pid'      genEnv    resPath     (IFunExp op' [PExp{_exp=IClaferId{_sident=sid}}, exp2])
+  | op' == iJoin && sid == thisIdent = Concat (IrPExp pid') [CString "this.", optBrArg genEnv resPath exp2]
+  | op' == iJoin && sid == rootIdent = genPExp' genEnv resPath exp2
+genIFunExp    pid'      genEnv    resPath     (IFunExp op' [exp'])
+  | op' == iInitially = Concat (IrPExp pid') [CString $ "(" ++ appearsNow genEnv resPath ++ ") implies ", brArg (genPExp' genEnv resPath) exp']
+  | op' == iFinally   = Concat (IrPExp pid') [CString $ "(some " ++ thisAlive genEnv resPath ++ " and after no " ++ thisAlive genEnv resPath ++ ") implies ", brArg (genPExp' genEnv resPath) exp']
+  -- the value of an initializer of the context clafer x, with temporal operators: it is
+  -- evaluated in the context of the parent of x, where it is written (gsdlab/clafer#123). Its
+  -- obligations last as long as the parent of the parent, and initially and finally refer to
+  -- the lifetime of the parent. The names in it are already paths from this, the instance of x.
+  | op' == iInitValue = case resPath of
+      ctx : rest | Just c <- findIClafer (uidIClaferMap genEnv) ctx, Just p <- parentOf genEnv c ->
+        brArg (genPExp' genEnv{contextInstance = "(" ++ contextInstance genEnv ++ "." ++ fixedParentRel genEnv c ++ ")"} (_uid p : rest)) (pushNegations True exp')
+      _ -> brArg (genPExp' genEnv resPath) (pushNegations True exp')
+  -- the obligations hold while the parent of the context instance exists
+  | Just p <- parentExists genEnv resPath, op' == iX =
+      Concat (IrPExp pid') [CString $ "after (not " ++ p ++ " or ", e, CString ")"]
+  | Just p <- parentExists genEnv resPath, op' == iF =
+      Concat (IrPExp pid') [CString $ "eventually (not " ++ p ++ " or ", e, CString ")"]
+  | Just p <- parentExists genEnv resPath, op' == iG =
+      Concat (IrPExp pid') [CString $ "(not " ++ p ++ ") releases (not " ++ p ++ " or ", e, CString ")"]
+  where
+  e = brArg (genPExp' genEnv resPath) exp'
+genIFunExp    pid'      genEnv    resPath     (IFunExp op' [exp1, exp2])
+  | Just p <- parentExists genEnv resPath, op' == iU =
+      Concat (IrPExp pid') [CString $ "(" ++ p ++ " and ", brArg (genPExp' genEnv resPath) exp1,
+                             CString $ ") until (not " ++ p ++ " or ", brArg (genPExp' genEnv resPath) exp2, CString ")"]
+genIFunExp    pid'      genEnv    resPath     (IFunExp op' exps')
+  | op' == iSumSet = genIFunExp pid' genEnv resPath (IFunExp iSumSet' [removeright (head exps'), getRight $ head exps'])
+  | op' == iSumSet' = Concat (IrPExp pid') $ intl exps'' (map CString $ genOp iSumSet)
+  | otherwise       = Concat (IrPExp pid') $ intl exps'' (map CString $ genOp op')
+  where
+      iSumSet' = "sum'"
+      intl
+        | op' == iSumSet' = flip interleave
+        | op' `elem` arithBinOps && length exps' == 2 = interleave
+        | otherwise = \xs ys -> reverse $ interleave (reverse xs) (reverse ys)
+      exps'' = map (optBrArg genEnv resPath) exps'
+genIFunExp _ _ _ x = error $ "[bug] AlloyLtl.genIFunExp: expecting a IFunExp, instead got: " ++ show x
+
+optBrArg :: GenEnv -> [String] -> PExp -> Concat
+optBrArg    genEnv    resPath     x     = brFun (genPExp' genEnv resPath) x
+  where
+  brFun = case x of
+    PExp _ _ _ IClaferId{} -> ($)
+    PExp _ _ _ (IInt _) -> ($)
+    _  -> brArg
+
+interleave :: [Concat] -> [Concat] -> [Concat]
+interleave [] [] = []
+interleave (x:xs) [] = x:xs
+interleave [] (x:xs) = x:xs
+interleave (x:xs) ys = x : interleave ys xs
+
+brArg :: (a -> Concat) -> a -> Concat
+brArg f arg = cconcat [CString "(", f arg, CString ")"]
+
+genOp :: String -> [String]
+genOp    op'
+  | op' == iX = ["after "]
+  | op' == iF = ["eventually "]
+  | op' == iG = ["always "]
+  | op' == iU = [" until "]
+  | op' == iPlus = [".plus[", "]"]
+  | op' == iSub  = [".minus[", "]"]
+  | op' == iSumSet = ["sum temp : "," | temp."]
+  | op' == iProdSet = ["prod temp : "," | temp."]
+  | op' `elem` unOps  = [op']
+  | op' == iMul = [".mul[", "]"]
+  | op' == iDiv = [".div[", "]"]
+  | op' == iRem = [".rem[", "]"]
+  | op' `elem` logBinOps ++ relBinOps ++ arithBinOps = [" " ++ op' ++ " "]
+  | op' == iUnion = [" + "]
+  | op' == iDifference = [" - "]
+  | op' == iIntersection = [" & "]
+  | op' == iDomain = [" <: "]
+  | op' == iRange = [" :> "]
+  | op' == iJoin = ["."]
+  | op' == iIfThenElse = [" => ", " else "]
+genOp op' = error $ "[bug] AlloyLtl.genOp: Unmatched operator: " ++ op'
+
+-- | Replaces the navigation to the parent with the relation to the parent.
+adjustPExp :: GenEnv -> [String] -> PExp -> PExp
+adjustPExp genEnv resPath (PExp t pid' pos x) = PExp t pid' pos $ adjustIExp genEnv resPath x
+
+adjustIExp :: GenEnv -> [String] -> IExp -> IExp
+adjustIExp genEnv resPath x = case x of
+  IDeclPExp q d pexp -> IDeclPExp q d $ adjustPExp genEnv resPath pexp
+  IFunExp op' exps' -> adjNav $ IFunExp op' $ map adjExps exps'
+    where
+    (adjNav, adjExps) = if op' == iJoin then (aNav, id)
+                        else (id, adjustPExp genEnv resPath)
+  IClaferId{} -> aNav x
+  _  -> x
+  where
+  aNav = fst . adjustNav genEnv resPath
+
+adjustNav :: GenEnv -> [String] -> IExp -> (IExp, [String])
+adjustNav genEnv resPath x@(IFunExp op' (pexp0:pexp:_))
+  | op' == iJoin = (IFunExp iJoin [pexp0{_exp = iexp0}, pexp{_exp = iexp}], path')
+  | otherwise   = (x, resPath)
+  where
+  (iexp0, path) = adjustNav genEnv resPath (_exp pexp0)
+  (iexp, path') = adjustNav genEnv (typePath path) (_exp pexp)
+  -- the right operand navigates from the clafer of the left one, e.g., a variable @b1@ in @b1.parent@
+  typePath p = case _iType pexp0 of
+    Just (TClafer (uid':_)) | isJust (findIClafer (uidIClaferMap genEnv) uid') -> uid' : drop 1 p
+    _ -> p
+adjustNav genEnv resPath x@(IClaferId _ id' _ _)
+  | id' == parentIdent = (x{_sident = parentRel genEnv $ head resPath}, parentPath)
+  | otherwise          = (x, resPath)
+  where
+  -- the path continues with the parent of the context clafer
+  parentPath = case findIClafer (uidIClaferMap genEnv) (head resPath) >>= parentOf genEnv of
+    Just p  -> _uid p : tail resPath
+    Nothing -> tail resPath
+adjustNav _ _ _ = error "AlloyLtl.adjustNav: expects a IFunExp or IClaferId"
+
+genQuant :: IQuant -> String
+genQuant    x       = case x of
+  INo   -> "no"
+  ILone -> "lone"
+  IOne  -> "one"
+  ISome -> "some"
+  IAll -> "all"
+
+genDecl :: GenEnv -> [String] -> IDecl -> Concat
+genDecl    genEnv    resPath     x      = case x of
+  IDecl disj locids pexp -> cconcat [CString $ if disj then "disj" else "", CString " ",
+    CString $ intercalate ", " locids, CString " : ", genPExp genEnv resPath pexp]
+
+removeright :: PExp -> PExp
+removeright (PExp _ _ _ (IFunExp _ (x : PExp _ _ _ IClaferId{} : _))) = x
+removeright (PExp _ _ _ (IFunExp _ (x : PExp _ _ _ (IInt _ ) : _))) = x
+removeright (PExp _ _ _ (IFunExp _ (x : PExp _ _ _ (IStr _ ) : _))) = x
+removeright (PExp _ _ _ (IFunExp _ (x : PExp _ _ _ (IDouble _ ) : _))) = x
+removeright (PExp t id' pos (IFunExp o (x1:x2:xs))) = PExp t id' pos (IFunExp o (x1:removeright x2:xs))
+removeright x@PExp{} = error $ "[bug] AlloyLtl.removeright: expects a PExp with a IFunExp inside but was given: " ++ show x
+
+getRight :: PExp -> PExp
+getRight (PExp _ _ _ (IFunExp _ (_:x:_))) = getRight x
+getRight p = p
+
+-- mapping line/columns between Clafer and Alloy code
+
+data AlloyEnv = AlloyEnv {
+  lineCol :: (LineNo, ColNo),
+  mapping :: [(Span, IrTrace)]
+  } deriving (Eq,Show)
+
+mapLineCol :: Concat -> [(Span, IrTrace)]
+mapLineCol code = mapping $ execState (mapLineCol' code) (AlloyEnv (firstLine, firstCol) [])
+
+addCode :: MonadState AlloyEnv m => String -> m ()
+addCode str = modify (\s -> s {lineCol = lineno (lineCol s) str})
+
+mapLineCol' :: MonadState AlloyEnv m => Concat -> m ()
+mapLineCol' (CString str) = addCode str
+mapLineCol' c@(Concat srcPos' n) = do
+  posStart <- gets lineCol
+  mapM_ mapLineCol' n
+  posEnd   <- gets lineCol
+  -- Alloy counts the inner parentheses as part of a constraint, but not the outer ones
+  let flat = flatten c
+      raiseStart = countLeading "([" flat
+      deductEnd = -(countTrailing ")]" flat)
+  modify (\s -> s {mapping = (Span (uncurry Pos $ posStart `addColumn` raiseStart) (uncurry Pos $ posEnd `addColumn` deductEnd), srcPos') : mapping s})
+
+addColumn :: Interval -> Integer -> Interval
+addColumn (x, y) c = (x, y + c)
+countLeading :: String -> String -> Integer
+countLeading c xs = toInteger $ length $ takeWhile (`elem` c) xs
+countTrailing :: String -> String -> Integer
+countTrailing c xs = countLeading c (reverse xs)
+
+lineno :: (Integer, ColNo) -> String -> (Integer, ColNo)
+lineno (l, c) str = (l + newLines, (if newLines > 0 then firstCol else c) + newCol)
+  where
+  newLines = toInteger $ length $ filter (== '\n') str
+  newCol   = toInteger $ length $ takeWhile (/= '\n') $ reverse str
+
+firstCol :: ColNo
+firstCol  = 1 :: ColNo
+firstLine :: LineNo
+firstLine = 1 :: LineNo
diff --git a/src/Language/Clafer/Generator/AlloyNames.hs b/src/Language/Clafer/Generator/AlloyNames.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Clafer/Generator/AlloyNames.hs
@@ -0,0 +1,114 @@
+{-
+ Copyright (C) 2026 Michal Antkiewicz <http://gsd.uwaterloo.ca>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-}
+{- | The names of the clafers in the Alloy outputs.
+
+A clafer's Alloy name is its UID, unless the UID cannot be one: an Alloy keyword (e.g., @sig@), a
+function of @util/integer@, which the outputs open (e.g., @max@), or a name that the generators
+write (e.g., @show@). The generators also derive names from a clafer's name @u@: @r_u@ (the
+relation from the parent), @u_ref@ (the reference), @alive_u@ and @p_u@ (temporal models), which
+must differ from the names of all other clafers. A clafer whose UID cannot be its Alloy name gets
+@u_1@, @u_2@, ..., the first that is free. Only those clafers are renamed; the UIDs, and all
+other outputs, are unchanged.
+-}
+module Language.Clafer.Generator.AlloyNames
+  ( alloyNames
+  , toAlloyNames
+  , fromAlloyName
+  , alloyReserved
+  ) where
+
+import           Control.Lens (over)
+import           Control.Lens.Plated
+import           Data.Char (isDigit)
+import           Data.Data.Lens
+import           Data.List
+import qualified Data.Map as Map
+import           Data.Maybe
+import qualified Data.Set as Set
+
+import           Language.Clafer.Intermediate.Intclafer
+
+-- | The Alloy names of the clafers whose UIDs cannot be their Alloy names, by UID.
+alloyNames :: IModule -> Map.Map UID String
+alloyNames imodule = Map.fromList renamed
+  where
+    uids = map _uid (universeOn biplate imodule :: [IClafer])
+    allUids = Set.fromList uids
+    -- the UIDs that can be Alloy names, in the order of the model, with the names they use
+    (used, toRename) = foldl keep (Set.empty, []) uids
+    keep (used', rest) u
+      | u `Set.member` alloyReserved || looksGenerated u || any (`Set.member` used') (derived u) = (used', rest ++ [u])
+      | otherwise = (foldr Set.insert used' (derived u), rest)
+    renamed = snd $ mapAccumL rename used toRename
+    rename used' u = (foldr Set.insert used' (derived name), (u, name))
+      where
+        name = fromJust $ find free [ u ++ "_" ++ show n | n <- [1 :: Int ..] ]
+        free n = n `Set.notMember` allUids && all (`Set.notMember` used') (derived n)
+
+-- | The UID of a clafer given its Alloy name.
+fromAlloyName :: Map.Map UID String -> String -> UID
+fromAlloyName names name = fromMaybe name $ lookup name [ (n, u) | (u, n) <- Map.toList names ]
+
+-- | The names the generators derive from a clafer's name.
+derived :: String -> [String]
+derived u = [u, "r_" ++ u, u ++ "_ref", "alive_" ++ u, "p_" ++ u]
+
+-- | Writes the clafers of a module with their Alloy names: their UIDs, their parents, the
+--   clafers in the expressions and in the types.
+toAlloyNames :: Map.Map UID String -> IModule -> IModule
+toAlloyNames names imodule
+  | Map.null names = imodule
+  | otherwise = over biplate renameType $ transformOn biplate renameExp $ transformOn biplate renameClafer imodule
+  where
+    r u = Map.findWithDefault u u names
+    renameClafer c = c{_uid = r (_uid c), _parentUID = r (_parentUID c)}
+    renameExp e@IClaferId{_sident = s, _binding = b} = case b of
+      LocalBind _  -> e
+      GlobalBind u -> e{_sident = r s, _binding = GlobalBind (r u)}
+      NoBind       -> e{_sident = r s}
+    renameExp e = e
+    renameType (TClafer hi') = TClafer (map r hi')
+    renameType (TMap so' ta') = TMap (renameType so') (renameType ta')
+    renameType (TUnion un') = TUnion (map renameType un')
+    renameType t = t
+
+-- | A name that the Alloy generator writes for an assertion, e.g., assertAt_3_5.
+looksGenerated :: String -> Bool
+looksGenerated n = case stripPrefix "assertAt_" n of
+  Just rest -> case break (== '_') rest of
+    (line, '_' : column) -> not (null line) && all isDigit line && not (null column) && all isDigit column
+    _ -> False
+  Nothing -> False
+
+-- | The names that cannot be clafers' names in Alloy: the keywords of Alloy 6, the functions of
+--   util/integer and the names the generators write.
+alloyReserved :: Set.Set String
+alloyReserved = Set.fromList $
+  [ "abstract", "all", "and", "as", "assert", "but", "check", "disj", "else", "enum", "exactly"
+  , "expect", "extends", "fact", "for", "fun", "iden", "iff", "implies", "in", "Int", "int", "let"
+  , "lone", "module", "no", "none", "not", "one", "open", "or", "pred", "private", "run", "seq"
+  , "set", "sig", "some", "String", "sum", "this", "univ", "var", "steps", "always", "eventually"
+  , "after", "before", "historically", "once", "since", "until", "releases", "triggered" ] ++
+  [ "add", "plus", "sub", "minus", "mul", "div", "rem", "negate", "eq", "gt", "lt", "gte", "lte"
+  , "zero", "pos", "neg", "nonpos", "nonneg", "signum", "int2elem", "elem2int", "max", "min"
+  , "next", "prev", "nexts", "prevs", "larger", "smaller" ] ++
+  [ "show", "ref", "self_", "children", "integer", "util" ]
diff --git a/src/Language/Clafer/Generator/Choco.hs b/src/Language/Clafer/Generator/Choco.hs
--- a/src/Language/Clafer/Generator/Choco.hs
+++ b/src/Language/Clafer/Generator/Choco.hs
@@ -23,223 +23,143 @@
 -- | Generates JS representation of IR for the <https://github.com/gsdlab/chocosolver Chocosolver>.
 module Language.Clafer.Generator.Choco (genCModule) where
 
-import Control.Applicative
-import Control.Lens.Plated hiding (rewrite)
-import Control.Monad
-import Data.Data.Lens
 import Data.List
-import Data.Maybe
-import Prelude hiding (exp)
+import qualified Data.Map as Map
 import Language.Clafer.Common
-import Language.Clafer.Intermediate.Intclafer
 import Language.Clafer.Front.LexClafer
-
-
--- | Choco 3 code generation
-genCModule :: (IModule, GEnv) -> [(UID, Integer)] -> [Token]     -> Result
-genCModule (imodule@IModule{_mDecls}, genv') scopes  otherTokens' =
-    genScopes
-    ++ "\n"
-    ++ (genClafers =<< _mDecls)
-    ++ (genSuperRefConstraintAssertGoal "root" =<< _mDecls)
-    ++ genChocoEscapes
-    where
-    uidIClaferMap' = uidClaferMap genv'
-
-    genClafers :: IElement -> String
-    genClafers    (IEClafer (c@IClafer{_uid, _gcard, _elements}))
-        = _uid
-        ++ genClaferNesting c
-        ++ prop "withGroupCard" (genCard $ _interval <$> _gcard)
-        ++ ";\n"
-        ++ (genClafers =<< _elements)
-    genClafers    _ = ""
-
-    genClaferNesting (IClafer{_isAbstract=True, _uid, _parentUID="clafer"})
-        = " = Abstract(\"" ++ _uid ++ "\")"
-    genClaferNesting (IClafer{_isAbstract=True, _uid, _parentUID})
-        = " = " ++ _parentUID ++  ".addAbstractChild(\"" ++ _uid ++ "\")"
-    genClaferNesting (IClafer{_isAbstract=False, _uid, _card, _parentUID="root"})
-        = " = Clafer(\"" ++ _uid ++ "\")"
-        ++ prop "withCard" (genCard _card)
-    genClaferNesting (IClafer{_isAbstract=False, _uid, _card, _parentUID})
-        = " = "
-        ++ _parentUID
-        ++  ".addChild(\"" ++ _uid ++ "\")"
-        ++ prop "withCard" (genCard _card)
-
-    prop name value =
-        case value of
-                Just value' -> "." ++ name ++ "(" ++ value' ++ ")"
-                Nothing     -> ""
-
-    claferWithUid u = fromMaybe (error $ "claferWithUid: \"" ++ u ++ "\" is not a clafer") $ findIClafer uidIClaferMap' u
-
-    superOf u =
-        case _super $ claferWithUid u of
-            Just (PExp{_exp = IClaferId{_sident}})
-                | _sident == baseClafer -> Nothing
-                | isPrimitive _sident   -> Nothing
-                | otherwise             -> Just _sident
-            _ -> Nothing
-
-    genCard :: Maybe Interval -> Maybe String
-    genCard (Just (0, -1)) = Nothing
-    genCard (Just (low, -1)) = return $ show low
-    genCard (Just (low, high)) = return $ show low ++ ", " ++ show high
-    genCard _              = Nothing
-
+import Language.Clafer.Generator.ChocoModel
+import Language.Clafer.Intermediate.Intclafer
 
-    genScopes :: Result
-    genScopes =
-        (if null scopeMap then "" else "scope({" ++ intercalate ", " scopeMap ++ "});\n")
-        ++ "defaultScope(1);\n"
-        ++ "intRange(-" ++ show largestPositiveInt ++ ", " ++ show (largestPositiveInt - 1) ++ ");\n"
-        ++ "stringLength(" ++ show longestString ++ ");\n"
-        where
-            largestPositiveInt :: Integer
-            largestPositiveInt = 2 ^ (bitwidth - 1)
-            scopeMap = [uid' ++ ":" ++ show scope | (uid', scope) <- scopes, uid' /= "int"]
+-- | Choco 3 code generation, with the given smallest and largest integers, if any, and the
+--   number of fractional digits of decimals, if given
+genCModule :: (IModule, GEnv) -> [(UID, Integer)] -> (Maybe Integer, Maybe Integer) -> Maybe Integer -> [Token] -> Result
+genCModule ir scopes intRange decimalDigits otherTokens' = jsModel $ chocoModel ir scopes intRange decimalDigits otherTokens'
 
-    genChocoEscapes :: String
-    genChocoEscapes = concatMap printChocoEscape otherTokens'
-        where
-            printChocoEscape (PT _ (T_PosChoco code)) =  let
-                code' = fromJust $ stripPrefix "[choco|" code
-              in
-                take (length code' - 2) code'
-            printChocoEscape _                        = ""
+-- | The variable of a clafer: $ and its UID, e.g., $x for the clafer x, so that a clafer whose
+--   name is a function of chocosolver's API (e.g., join) or a word of JavaScript does not
+--   replace it.
+jsVar :: UID -> String
+jsVar = ('$' :)
 
-    exprs :: [IExp]
-    exprs = universeOn biplate imodule
+-- | The variable of a local of a quantifier: $_ and its name, e.g., $_x for x, apart from the
+--   clafers' variables (a name starts with a letter).
+jsLocalVar :: String -> String
+jsLocalVar = ("$_" ++)
 
-    stringLength :: IExp -> Maybe Int
-    stringLength (IStr string) = Just $ length string
-    stringLength _ = Nothing
+-- | The clafers, then their supers, then their references, and then the constraints.
+--   chocosolver checks a reference which refines an inherited one, e.g., @E1 : Edge -> N2@
+--   under @abstract Edge -> Node ?@, when it reads it: the target must extend the inherited
+--   target, and the super's reference must be known. So all the supers come before the
+--   references, also those of the clafers declared further down, and the reference of a
+--   super before those of its subclafers.
+jsModel :: CModel -> Result
+jsModel CModel{cmElements, cmScope, cmEscapes} =
+    jsScope cmScope
+    ++ "\n"
+    ++ (jsClafer =<< cmElements)
+    ++ (jsSuper =<< clafers)
+    ++ (jsRef =<< sortOn superDepth clafers)
+    ++ (jsLinks "root" =<< cmElements)
+    ++ cmEscapes
+  where
+    clafers = allCClafers cmElements
+    supers = Map.fromList [ (ccUid c, s) | c <- clafers, Just s <- [ccSuper c] ]
+    superDepth = depth [] . ccUid
+    depth visited uid' = case Map.lookup uid' supers of
+      Just s | s `notElem` visited -> 1 + depth (s : visited) s
+      _                            -> 0 :: Int
 
-    longestString :: Int
-    longestString = maximum $ 16 : mapMaybe stringLength exprs
+-- | The clafers, in pre-order
+allCClafers :: [CElement] -> [CClafer]
+allCClafers es = [ c' | CEClafer c <- es, c' <- c : allCClafers (ccElements c) ]
 
-    genSuperRefConstraintAssertGoal :: String -> IElement -> Result
-    genSuperRefConstraintAssertGoal _ IEClafer{_iClafer=IClafer{_uid, _super=Nothing, _reference=Nothing, _elements}}
-        = genSuperRefConstraintAssertGoal _uid =<< _elements
-    genSuperRefConstraintAssertGoal _ (IEClafer c@IClafer{_uid, _card, _super, _reference, _elements})
-        = _uid
-        ++ prop "extending" (superOf _uid)
-        ++ (case (getReference c, _reference) of
-             ([target], Just (IReference True _))  -> ".refToUnique(" ++ genTarget target ++ ")"
-             ([target], Just (IReference False _)) -> ".refTo(" ++ genTarget target ++ ")"
-             _ -> "")
-        ++ ";\n"
-        ++ (genSuperRefConstraintAssertGoal _uid =<< _elements)
-        where
-            genTarget "integer" = "Int"
-            genTarget "int" = "Int"
-            genTarget target = target
-    genSuperRefConstraintAssertGoal "root" (IEConstraint True pexp) = "Constraint(" ++ genConstraintPExp pexp ++ ");\n"
-    genSuperRefConstraintAssertGoal pUID (IEConstraint True pexp) = pUID ++ ".addConstraint(" ++ genConstraintPExp pexp ++ ");\n"
-    genSuperRefConstraintAssertGoal _ (IEConstraint False pexp) = "assert(" ++ genConstraintPExp pexp ++ ");\n"
-    genSuperRefConstraintAssertGoal _ (IEGoal True PExp{_exp=IFunExp _ [pexp]})  = "max(" ++ genConstraintPExp pexp ++ ");\n"
-    genSuperRefConstraintAssertGoal _ (IEGoal False PExp{_exp=IFunExp _ [pexp]})  = "min(" ++ genConstraintPExp pexp ++ ");\n"
-    genSuperRefConstraintAssertGoal _ _ = ""
+jsSuper :: CClafer -> Result
+jsSuper CClafer{ccUid, ccLinked, ccSuper = Just super'} | ccLinked = jsVar ccUid ++ ".extending(" ++ jsVar super' ++ ");\n"
+jsSuper _ = ""
 
+jsRef :: CClafer -> Result
+jsRef CClafer{ccUid, ccLinked, ccRef = Just ref'} | ccLinked = jsVar ccUid ++ refTo ref' ++ ";\n"
+  where
+    refTo (True, target)  = ".refToUnique(" ++ jsTarget target ++ ")"
+    refTo (False, target) = ".refTo(" ++ jsTarget target ++ ")"
+    jsTarget "integer" = "Int"
+    jsTarget "int" = "Int"
+    jsTarget "decimal" = "Decimal"
+    jsTarget "string" = "string"
+    jsTarget target = jsVar target
+jsRef _ = ""
 
-    rewrite :: PExp -> PExp
-    -- Rearrange right joins to left joins.
-    rewrite p1@PExp{_iType = Just _, _exp = IFunExp "." [p2, p3@PExp{_exp = IFunExp "." _}]} =
-        p1{_exp = IFunExp "." [p3{_iType = _iType p4, _exp = IFunExp "." [p2, p4]}, p5]}
-        where
-            PExp{_exp = IFunExp "." [p4, p5]} = rewrite p3
-    rewrite p1@PExp{_exp = IFunExp{_op = "-", _exps = [PExp{_exp = IInt i}]}} =
-        -- This is so that the output looks cleaner, no other purpose since the Choco optimizer
-        -- in the backend will treat the pre-rewritten expression the same.
-        p1{_exp = IInt (-i)}
-    rewrite p = p
+jsScope :: CScope -> Result
+jsScope CScope{csClafers, csIntRange, csStringLength, csDecimalScale} =
+    -- chocosolver looks the keys up as the clafers' variables
+    (if null csClafers then "" else "scope({" ++ intercalate ", " [jsVar uid' ++ ":" ++ show scope | (uid', scope) <- csClafers] ++ "});\n")
+    ++ "defaultScope(1);\n"
+    ++ maybe "" (\(low, high) -> "intRange(" ++ show low ++ ", " ++ show high ++ ");\n") csIntRange
+    ++ "stringLength(" ++ show csStringLength ++ ");\n"
+    ++ maybe "" (\scale -> "decimalScale(" ++ show scale ++ ");\n") csDecimalScale
 
-    genConstraintPExp :: PExp -> String
-    genConstraintPExp = genConstraintExp . _exp . rewrite
+-- | The clafers, nested
+jsClafer :: CElement -> Result
+jsClafer (CEClafer CClafer{ccUid, ccParent, ccAbstract, ccCard, ccGCard, ccElements}) =
+    jsVar ccUid
+    ++ nesting
+    ++ prop "withGroupCard" (jsCard ccGCard)
+    ++ ";\n"
+    ++ (jsClafer =<< ccElements)
+  where
+    nesting
+        | ccAbstract && ccParent == "clafer" = " = Abstract(\"" ++ ccUid ++ "\")"
+        | ccAbstract                         = " = " ++ jsVar ccParent ++ ".addAbstractChild(\"" ++ ccUid ++ "\")"
+        | ccParent == "root"                 = " = Clafer(\"" ++ ccUid ++ "\")" ++ prop "withCard" (jsCard ccCard)
+        | otherwise                          = " = " ++ jsVar ccParent ++ ".addChild(\"" ++ ccUid ++ "\")" ++ prop "withCard" (jsCard ccCard)
+jsClafer _ = ""
 
-    genConstraintExp :: IExp -> String
-    genConstraintExp (IDeclPExp quant' [] body') =
-        mapQuant quant' ++ "(" ++ genConstraintPExp body' ++ ")"
-    genConstraintExp (IDeclPExp quant' decls' body') =
-        mapQuant quant' ++ "([" ++ intercalate ", " (map genDecl decls') ++ "], " ++ genConstraintPExp body' ++ ")"
-        where
-            genDecl (IDecl isDisj' locals body'') =
-                (if isDisj' then "disjDecl" else "decl") ++ "([" ++ intercalate ", " (map genLocal locals) ++ "], " ++ genConstraintPExp body'' ++ ")"
-            genLocal local =
-                local ++ " = local(\"" ++ local ++ "\")"
+-- | The constraints, objectives and assertions, in the context of a clafer
+jsLinks :: String -> CElement -> Result
+jsLinks _ (CEClafer CClafer{ccUid, ccLinked, ccRefConstraints, ccElements})
+    | ccLinked =
+        concatMap (\c -> jsVar ccUid ++ ".addConstraint(" ++ jsExp c ++ ");\n") ccRefConstraints
+        ++ (jsLinks ccUid =<< ccElements)
+    | otherwise = jsLinks ccUid =<< ccElements
+jsLinks "root" (CEConstraint e) = "Constraint(" ++ jsExp e ++ ");\n"
+jsLinks pUID (CEConstraint e) = jsVar pUID ++ ".addConstraint(" ++ jsExp e ++ ");\n"
+jsLinks _ (CEAssert e) = "assert(" ++ jsExp e ++ ");\n"
+jsLinks _ (CEObjective True e) = "max(" ++ jsExp e ++ ");\n"
+jsLinks _ (CEObjective False e) = "min(" ++ jsExp e ++ ");\n"
 
-    genConstraintExp (IFunExp "." [PExp{_exp = IClaferId{_sident = "root"}}, e2]) =
-        genConstraintPExp e2
-    genConstraintExp (IFunExp "." [e1, PExp{_exp = IClaferId{_sident = "dref"}}]) =
-        "joinRef(" ++ genConstraintPExp e1 ++ ")"
-    genConstraintExp (IFunExp "." [e1, PExp{_exp = IClaferId{_sident = "parent"}}]) =
-        "joinParent(" ++ genConstraintPExp e1 ++ ")"
-    genConstraintExp (IFunExp "." [e1, PExp{_exp = IClaferId{_sident}}]) =
-        "join(" ++ genConstraintPExp e1 ++ ", " ++ _sident ++ ")"
-    genConstraintExp (IFunExp "." [_, _]) =
-        error "Did not rewrite all joins to left joins."
-    genConstraintExp (IFunExp "-" [arg]) =
-        "minus(" ++ genConstraintPExp arg ++ ")"
-    genConstraintExp (IFunExp "-" [arg1, arg2]) =
-        "sub(" ++ genConstraintPExp arg1 ++ ", " ++ genConstraintPExp arg2 ++ ")"
-    genConstraintExp (IFunExp "sum" args')
-        | [arg] <- args', PExp{_exp = IFunExp{_exps = [a, PExp{_exp = IClaferId{_sident = "dref"}}]}} <- rewrite arg =
-            "sum(" ++ genConstraintPExp a ++ ")"
-        | [arg] <- args' =
-            "sum(" ++ genConstraintPExp arg ++ ")"
-        | otherwise = error $ "[bug] Choco.genConstraintExp: Unexpected sum argument: " ++ show args'
-    genConstraintExp (IFunExp "product" args')
-        | [arg] <- args', PExp{_exp = IFunExp{_exps = [a, PExp{_exp = IClaferId{_sident = "dref"}}]}} <- rewrite arg =
-            "product(" ++ genConstraintPExp a ++ ")"
-        | otherwise = error "Choco: Unexpected product argument."
-    genConstraintExp (IFunExp "+" args') =
-        (if _iType (head args') == Just TString then "concat" else "add") ++
-            "(" ++ intercalate ", " (map genConstraintPExp args') ++ ")"
-    genConstraintExp (IFunExp op' args') =
-        mapFunc op' ++ "(" ++ intercalate ", " (map genConstraintPExp args') ++ ")"
-    -- this is a keyword in Javascript so use "$this" instead
-    genConstraintExp IClaferId{_sident = "this"} = "$this()"
-    genConstraintExp IClaferId{_sident}
-        | isJust $ findIClafer uidIClaferMap' _sident = "global(" ++ _sident ++ ")"
-        | otherwise                = _sident
-    genConstraintExp (IInt val) = "constant(" ++ show val ++ ")"
-    genConstraintExp (IStr val) = "constant(" ++ show val ++ ")"
-    genConstraintExp (IDouble val) = "constant(" ++ show val ++ ")"
-    genConstraintExp (IReal val) = "constant(" ++ show val ++ ")"
+prop :: String -> Maybe String -> String
+prop name = maybe "" (\value -> "." ++ name ++ "(" ++ value ++ ")")
 
-    mapQuant INo = "none"
-    mapQuant ISome = "some"
-    mapQuant IAll = "all"
-    mapQuant IOne = "one"
-    mapQuant ILone = "lone"
+jsCard :: Maybe Interval -> Maybe String
+jsCard (Just (low, -1))   = Just $ show low
+jsCard (Just (low, high)) = Just $ show low ++ ", " ++ show high
+jsCard Nothing            = Nothing
 
-    mapFunc "!" = "not"
-    mapFunc "#" = "card"
-    mapFunc "min" = "minimum"
-    mapFunc "max" = "maximum"
-    mapFunc "<=>" = "ifOnlyIf"
-    mapFunc "=>" = "implies"
-    mapFunc "||" = "or"
-    mapFunc "xor" = "xor"
-    mapFunc "&&" = "and"
-    mapFunc "<" = "lessThan"
-    mapFunc ">" = "greaterThan"
-    mapFunc "=" = "equal"
-    mapFunc "<=" = "lessThanEqual"
-    mapFunc ">=" = "greaterThanEqual"
-    mapFunc "!=" = "notEqual"
-    mapFunc "in" = "$in"
-    mapFunc "not in" = "notIn"
-    mapFunc "+" = "add"
-    mapFunc "*" = "mul"
-    mapFunc "/" = "div"
-    mapFunc "%" = "mod"
-    mapFunc "++" = "union"
-    mapFunc "--" = "diff"
-    mapFunc "**" = "inter"
-    mapFunc "ifthenelse" = "ifThenElse"
-    mapFunc op' = error $ "Choco: Unknown op: " ++ op'
+jsExp :: CExp -> String
+jsExp CThis = "$this()"  -- this is a keyword in Javascript
+jsExp (CGlobal u) = "global(" ++ jsVar u ++ ")"
+jsExp (CName n) = jsLocalVar n
+jsExp (CInt val) = "constant(" ++ show val ++ ")"
+jsExp (CStr val) = "constant(" ++ show val ++ ")"
+jsExp (CDouble val) = "constant(" ++ show val ++ ")"
+jsExp (CDecimal val) = "decimal(\"" ++ val ++ "\")"
+jsExp (CEmpty "Int") = "constant(Int)"
+jsExp (CEmpty c) = "constant(" ++ jsVar c ++ ")"
+jsExp (CJoin e c) = "join(" ++ jsExp e ++ ", " ++ jsVar c ++ ")"
+jsExp (CJoinRef e) = "joinRef(" ++ jsExp e ++ ")"
+jsExp (CJoinParent e) = "joinParent(" ++ jsExp e ++ ")"
+jsExp (CFun f args') = f ++ "(" ++ intercalate ", " (map jsExp args') ++ ")"
+jsExp (CQuant q [] body') = jsQuant q ++ "(" ++ jsExp body' ++ ")"
+jsExp (CQuant q decls' body') =
+    jsQuant q ++ "([" ++ intercalate ", " (map jsDecl decls') ++ "], " ++ jsExp body' ++ ")"
+  where
+    jsDecl (CDecl isDisj' locals body'') =
+        (if isDisj' then "disjDecl" else "decl") ++ "([" ++ intercalate ", " (map jsLocal locals) ++ "], " ++ jsExp body'' ++ ")"
+    jsLocal local = jsLocalVar local ++ " = local(\"" ++ local ++ "\")"
 
-    bitwidth = fromMaybe 4 $ lookup "int" scopes :: Integer
+jsQuant :: IQuant -> String
+jsQuant INo = "none"
+jsQuant ISome = "some"
+jsQuant IAll = "all"
+jsQuant IOne = "one"
+jsQuant ILone = "lone"
diff --git a/src/Language/Clafer/Generator/ChocoModel.hs b/src/Language/Clafer/Generator/ChocoModel.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Clafer/Generator/ChocoModel.hs
@@ -0,0 +1,407 @@
+{-# LANGUAGE NamedFieldPuns #-}
+{-
+ Copyright (C) 2012-2017 Jimmy Liang, Michal Antkiewicz, Rafael Olaechea <http://gsd.uwaterloo.ca>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-}
+-- | The model the <https://github.com/gsdlab/chocosolver Chocosolver> solves, built by one walk
+--   over the IR, which "Language.Clafer.Generator.Choco" prints as JavaScript and
+--   "Language.Clafer.Generator.Explicit" as an explicit Clafer model, so that both give the same
+--   model.
+module Language.Clafer.Generator.ChocoModel
+  ( CModel(..)
+  , CElement(..)
+  , CClafer(..)
+  , CExp(..)
+  , CDecl(..)
+  , CScope(..)
+  , chocoModel
+  ) where
+
+import Control.Applicative
+import Control.Lens.Plated hiding (rewrite)
+import Control.Monad
+import Data.Data.Lens
+import Data.List
+import Data.Maybe
+import Prelude hiding (exp)
+import Language.Clafer.Common
+import Language.Clafer.Intermediate.Intclafer
+import Language.Clafer.Front.LexClafer
+
+-- | A formula over the target of a reference, simplified when constant.
+data Membership = MTrue | MFalse | MExp CExp
+
+-- | The model chocosolver gets: its clafers and the elements in them, in the order of the IR.
+data CModel = CModel
+    { cmElements :: [CElement]    -- ^ the top-level clafers, constraints, objectives and assertions
+    , cmScope    :: CScope
+    , cmEscapes  :: String        -- ^ the [choco| |] escapes, JavaScript
+    }
+
+data CElement
+    = CEClafer CClafer
+    | CEConstraint CExp
+    | CEAssert CExp               -- ^ an assertion, quantified over its clafer if nested
+    | CEObjective Bool CExp       -- ^ maximize, or minimize
+
+data CClafer = CClafer
+    { ccUid      :: UID
+    , ccParent   :: UID           -- ^ "clafer" for a top-level abstract clafer, "root" for a top-level concrete one
+    , ccAbstract :: Bool
+    , ccModifiers :: [String]     -- ^ its temporal modifiers, e.g., initial, final, finalref, which chocosolver does not read
+    , ccCard     :: Maybe Interval   -- ^ only if not 0..*
+    , ccGCard    :: Maybe Interval   -- ^ only if not 0..*
+    , ccLinked   :: Bool          -- ^ whether it has a super clafer or a reference in the IR
+    , ccSuper    :: Maybe UID     -- ^ a clafer
+    , ccRef      :: Maybe (Bool, String)   -- ^ its own reference: whether a set, and the target
+    , ccRefConstraints :: [CExp]  -- ^ the constraints of a reference to a set expression
+    , ccElements :: [CElement]
+    }
+
+-- | An expression, by the functions of chocosolver's JavaScript API.
+data CExp
+    = CThis
+    | CGlobal UID                 -- ^ all instances of a clafer
+    | CName String                -- ^ a local
+    | CInt Integer
+    | CStr String                 -- ^ a Clafer string literal, with its quotes
+    | CDouble Double
+    | CDecimal String             -- ^ as written, with the fractional digits of the decimal scale
+    | CEmpty String               -- ^ the empty set, typed by a clafer (or Int)
+    | CJoin CExp String
+    | CJoinRef CExp
+    | CJoinParent CExp
+    | CFun String [CExp]          -- ^ a function of the API by its name, e.g., equal
+    | CQuant IQuant [CDecl] CExp  -- ^ without declarations, a quantifier over a set, e.g., none(x)
+
+data CDecl = CDecl Bool [String] CExp
+
+-- | The scopes, as chocosolver solves the model with no options.
+data CScope = CScope
+    { csClafers       :: [(UID, Integer)]   -- ^ the scopes given, without int
+    , csIntRange      :: Maybe (Integer, Integer)
+    , csStringLength  :: Int
+    , csDecimalScale  :: Maybe Integer      -- ^ only if the model uses decimals or the scale is given
+    }
+
+-- | The model of the IR, with the given scopes, smallest and largest integers, if any, number of
+--   fractional digits of decimals, if given, and the tokens with the [choco| |] escapes
+chocoModel :: (IModule, GEnv) -> [(UID, Integer)] -> (Maybe Integer, Maybe Integer) -> Maybe Integer -> [Token] -> CModel
+chocoModel (imodule@IModule{_mDecls}, genv') scopes (minInt, maxInt) decimalDigits otherTokens' =
+    CModel
+    { cmElements = mapMaybe (genElement "root") _mDecls
+    , cmScope = CScope
+        { csClafers = [(uid', scope) | (uid', scope) <- scopes, uid' /= "int"]
+        -- Without --minint and --maxint, chocosolver chooses the range (-128..127
+        -- unless overridden on its command line).
+        , csIntRange = if isNothing minInt && isNothing maxInt then Nothing
+                       else Just (fromMaybe (-128) minInt, fromMaybe 127 maxInt)
+        , csStringLength = longestString
+        , csDecimalScale = if usesDecimals || isJust decimalDigits then Just decimalScale else Nothing
+        }
+    , cmEscapes = genChocoEscapes
+    }
+    where
+    uidIClaferMap' = uidClaferMap genv'
+
+    genElement :: String -> IElement -> Maybe CElement
+    genElement _ (IEClafer c@IClafer{_uid, _card, _gcard, _super, _reference, _elements, _parentUID, _modifiers}) = Just $ CEClafer CClafer
+        { ccUid = _uid
+        , ccParent = _parentUID
+        , ccAbstract = _abstract _modifiers
+        , ccModifiers = temporalModifiers' _modifiers _reference
+        , ccCard = nonDefault _card
+        , ccGCard = nonDefault $ _interval <$> _gcard
+        , ccLinked = isJust _super || isJust _reference
+        , ccSuper = superOf _uid
+        , ccRef = case (getReference c, _reference) of
+             (_, Just (IReference isSet' _ ref')) | isSetExp ref', Just target <- setExpType ref' -> Just (isSet', target)
+             ([target], Just (IReference isSet' _ _))                                          -> Just (isSet', target)
+             _                                                                                  -> Nothing
+        , ccRefConstraints = case _reference of
+             Just (IReference _ _ ref') | isSetExp ref', Just _ <- setExpType ref' -> genSetExpTarget ref'
+             _                                                                     -> []
+        , ccElements = mapMaybe (genElement _uid) _elements
+        }
+    genElement _ (IEConstraint True pexp) = Just $ CEConstraint $ genConstraintPExp pexp
+    genElement "root" (IEConstraint False pexp) = Just $ CEAssert $ genConstraintPExp pexp
+    -- chocosolver's assertions have no context: a nested assertion holds for each instance of its
+    -- clafer, so it is quantified over them, with `this` as the local this_, e.g., in clafer P:
+    -- assert(all([decl([this_ = local("this_")], global(P))], ... join(this_, age) ...)); the
+    -- instances of a nested clafer by the path from its top-level clafer, as clafer resolves
+    -- its name, e.g., machine . ctx
+    genElement pUID (IEConstraint False pexp) = Just $ CEAssert $
+        CQuant IAll [CDecl False [thisLocal] (instancesOf pUID)] (genConstraintPExp (transformOn biplate thisToLocal pexp))
+      where
+        thisToLocal e@IClaferId{_sident = "this"} = e{_sident = thisLocal}
+        thisToLocal e = e
+        instancesOf u
+            | isTopLevel c = CGlobal u
+            | otherwise    = CJoin (instancesOf $ _parentUID c) u
+          where
+            c = claferWithUid u
+    genElement _ (IEGoal isMax PExp{_exp=IFunExp _ [pexp]}) = Just $ CEObjective isMax $ genConstraintPExp pexp
+    genElement _ _ = Nothing
+
+    thisLocal = "this_"
+
+    -- the temporal modifiers of a clafer: final, which implies finalref and finaltarget, or the
+    -- modifiers of its own reference or of the reference it inherits
+    temporalModifiers' IClaferModifiers{_initial, _final, _finalReferences} ref' =
+        [ "initial" | _initial ] ++ [ "final" | _final ] ++
+        [ refModifierKeyword m | not _final, m <- nub (maybe [] _refModifiers ref' ++ _finalReferences) ]
+    refModifierKeyword FinalRef = "finalref"
+    refModifierKeyword FinalTarget = "finaltarget"
+    refModifierKeyword FinalRefTarget = "final"
+
+    -- a card or group card, unless it is 0..*, which chocosolver has by default
+    nonDefault (Just (0, -1)) = Nothing
+    nonDefault i              = i
+
+    superOf u =
+        case _super $ claferWithUid u of
+            Just (PExp{_exp = IClaferId{_sident}})
+                | _sident == baseClafer -> Nothing
+                | isPrimitive _sident   -> Nothing
+                | otherwise             -> Just _sident
+            _ -> Nothing
+
+    claferWithUid u = fromMaybe (error $ "claferWithUid: \"" ++ u ++ "\" is not a clafer") $ findIClafer uidIClaferMap' u
+
+    genChocoEscapes :: String
+    genChocoEscapes = concatMap printChocoEscape otherTokens'
+        where
+            printChocoEscape (PT _ (T_PosChoco code)) =  let
+                code' = fromJust $ stripPrefix "[choco|" code
+              in
+                take (length code' - 2) code'
+            printChocoEscape _                        = ""
+
+    exprs :: [IExp]
+    exprs = universeOn biplate imodule
+
+    stringLength :: IExp -> Maybe Int
+    stringLength (IStr string) = Just $ length string
+    stringLength _ = Nothing
+
+    longestString :: Int
+    longestString = maximum $ 16 : mapMaybe stringLength exprs
+
+    -- | The number of fractional digits of a decimal literal, as written, e.g., 2 for 2.50
+    fractionalDigits :: String -> Integer
+    fractionalDigits literal = genericLength $ drop 1 $ dropWhile (/= '.') literal
+
+    decimalLiterals :: [String]
+    decimalLiterals = [ literal | IDecimal literal <- exprs ]
+
+    -- | Whether the model has decimal literals or references to decimals
+    usesDecimals :: Bool
+    usesDecimals = not (null decimalLiterals) || any refersToDecimal (universeOn biplate imodule :: [IClafer])
+      where
+        refersToDecimal IClafer{_reference = Just IReference{_ref = ref'}} = decimalType `elem` getRefIds ref'
+        refersToDecimal _ = False
+
+    -- | The decimal scale: the largest number of fractional digits of the decimal literals,
+    --   unless given by --decimal-digits
+    decimalScale :: Integer
+    decimalScale = fromMaybe (maximum $ 0 : map fractionalDigits decimalLiterals) decimalDigits
+
+    -- | A decimal literal with the fractional digits of the decimal scale, e.g., 2.5 as 2.50
+    --   with 2 digits; with more digits, chocosolver reports that the literal does not fit.
+    genDecimal :: String -> String
+    genDecimal literal = literal ++ genericReplicate (decimalScale - fractionalDigits literal) '0'
+
+    -- an empty set of the clafer; with no clafer beside it, e.g., in #noclafer, of the model's
+    -- first clafer, since chocosolver neither counts nor quantifies sets of integers
+    emptyOf :: Maybe String -> CExp
+    emptyOf c = CEmpty $ fromMaybe "Int" (c <|> firstClafer)
+    firstClafer = listToMaybe [ _uid c | IEClafer c <- _mDecls ]
+
+    -- the clafer whose instances a set expression is of, e.g., c0_a for a, its type's first; for
+    -- an expression of the type of noclafer, e.g., a ** noclafer, that of an operand
+    claferOf :: PExp -> Maybe String
+    claferOf PExp{_iType = t, _exp = e} = (claferOfType =<< t) <|> case e of
+        IFunExp _ args' -> listToMaybe $ mapMaybe claferOf args'
+        _ -> Nothing
+      where
+        claferOfType (TClafer (u : _)) | u `notElem` [noClaferIdent, rootIdent, baseClafer] = Just u
+        claferOfType (TMap so _) = claferOfType so
+        claferOfType (TUnion (t' : _)) = claferOfType t'
+        claferOfType _ = Nothing
+
+
+    -- A reference to a set expression, e.g., `-> 1, 2, 3`, `-> integer -- 0` or
+    -- `-> Alice ++ Ella`, is a reference to a type containing all its values,
+    -- constrained to the values of the expression.
+    isSetExp :: PExp -> Bool
+    isSetExp PExp{_exp = IFunExp op' _} = op' `elem` ["++", "**", "--"]
+    isSetExp _                          = False
+
+    -- | The type to reference: the primitive type of the values, or the nearest
+    -- common super of the clafers.
+    setExpType :: PExp -> Maybe String
+    setExpType ref' = case nub $ getRefIds ref' of
+        ids@(_:_) | all isPrimitive ids -> case sort $ nub $ map normalize ids of
+            [t] -> Just t
+            -- integers are decimals, e.g., in `-> 1, 2.5`
+            [d, i] | d == decimalType && i == integerType -> Just decimalType
+            _   -> Nothing
+                  | not (any isPrimitive ids) -> commonSuper ids
+        _ -> Nothing
+      where
+        normalize "int" = "integer"
+        normalize t     = t
+
+    commonSuper :: [String] -> Maybe String
+    commonSuper ids = case map supersOf ids of
+        (first:rest) -> find (\u -> all (u `elem`) rest) first
+        []           -> Nothing
+      where
+        supersOf uid' = uid' : maybe [] (tail . mapHierarchy _uid getSuper uidIClaferMap') (findIClafer uidIClaferMap' uid')
+
+    -- | Constrains the target of the reference to the values of the set expression.
+    genSetExpTarget :: PExp -> [CExp]
+    genSetExpTarget ref'
+        | Just _ <- setExpType ref', any isPrimitive (getRefIds ref') =
+            case member ref' of
+                MTrue    -> []
+                MFalse   -> [CQuant INo [] CThis]
+                MExp e'  -> [e']
+        | otherwise = [CFun "$in" [CJoinRef CThis, genConstraintPExp ref']]
+      where
+        -- membership of the target in a set expression over primitives, as a formula
+        member PExp{_exp = IFunExp "++" [a, b]} = mOr (member a) (member b)
+        member PExp{_exp = IFunExp "**" [a, b]} = mAnd (member a) (member b)
+        member PExp{_exp = IFunExp "--" [a, b]} = mAnd (member a) (mNot $ member b)
+        member PExp{_exp = IClaferId{_sident}} | isPrimitive _sident = MTrue
+        member e' = MExp $ CFun "equal" [CJoinRef CThis, genConstraintPExp e']
+        mOr MTrue _ = MTrue
+        mOr _ MTrue = MTrue
+        mOr MFalse b = b
+        mOr a MFalse = a
+        mOr (MExp a) (MExp b) = MExp $ CFun "or" [a, b]
+        mAnd MFalse _ = MFalse
+        mAnd _ MFalse = MFalse
+        mAnd MTrue b = b
+        mAnd a MTrue = a
+        mAnd (MExp a) (MExp b) = MExp $ CFun "and" [a, b]
+        mNot MTrue = MFalse
+        mNot MFalse = MTrue
+        mNot (MExp a) = MExp $ CFun "not" [a]
+
+    rewrite :: PExp -> PExp
+    -- Rearrange right joins to left joins.
+    rewrite p1@PExp{_iType = Just _, _exp = IFunExp "." [p2, p3@PExp{_exp = IFunExp "." _}]} =
+        p1{_exp = IFunExp "." [p3{_iType = _iType p4, _exp = IFunExp "." [p2, p4]}, p5]}
+        where
+            PExp{_exp = IFunExp "." [p4, p5]} = rewrite p3
+    rewrite p1@PExp{_exp = IFunExp{_op = "-", _exps = [PExp{_exp = IInt i}]}} =
+        -- This is so that the output looks cleaner, no other purpose since the Choco optimizer
+        -- in the backend will treat the pre-rewritten expression the same.
+        p1{_exp = IInt (-i)}
+    rewrite p = p
+
+    genConstraintPExp :: PExp -> CExp
+    genConstraintPExp = genConstraintExp . _exp . rewrite
+
+    genConstraintExp :: IExp -> CExp
+    genConstraintExp (IDeclPExp quant' decls' body') =
+        CQuant quant' (map genDecl decls') (genConstraintPExp body')
+        where
+            genDecl (IDecl isDisj' locals body'') = CDecl isDisj' locals (genConstraintPExp body'')
+
+    genConstraintExp (IFunExp "." [PExp{_exp = IClaferId{_sident = "root"}}, e2]) =
+        genConstraintPExp e2
+    genConstraintExp (IFunExp "." [e1, PExp{_exp = IClaferId{_sident = "dref"}}]) =
+        CJoinRef $ genConstraintPExp e1
+    genConstraintExp (IFunExp "." [e1, PExp{_exp = IClaferId{_sident = "parent"}}]) =
+        CJoinParent $ genConstraintPExp e1
+    genConstraintExp (IFunExp "." [e1, PExp{_exp = IClaferId{_sident}}]) =
+        CJoin (genConstraintPExp e1) _sident
+    genConstraintExp (IFunExp "." [_, _]) =
+        error "Did not rewrite all joins to left joins."
+    -- the value of an initializer with temporal operators, which the explicit form shows as it
+    -- is: its context is the parent (gsdlab/clafer#123), which only the temporal output keeps
+    genConstraintExp (IFunExp op' [arg]) | op' == iInitValue =
+        genConstraintPExp arg
+    genConstraintExp (IFunExp "-" [arg]) =
+        CFun "minus" [genConstraintPExp arg]
+    genConstraintExp (IFunExp "-" [arg1, arg2]) =
+        CFun "sub" [genConstraintPExp arg1, genConstraintPExp arg2]
+    genConstraintExp (IFunExp "sum" args')
+        | [arg] <- args', PExp{_exp = IFunExp{_exps = [a, PExp{_exp = IClaferId{_sident = "dref"}}]}} <- rewrite arg =
+            CFun "sum" [genConstraintPExp a]
+        | [arg] <- args' =
+            CFun "sum" [genConstraintPExp arg]
+        | otherwise = error $ "[bug] Choco.genConstraintExp: Unexpected sum argument: " ++ show args'
+    genConstraintExp (IFunExp "product" args')
+        | [arg] <- args', PExp{_exp = IFunExp{_exps = [a, PExp{_exp = IClaferId{_sident = "dref"}}]}} <- rewrite arg =
+            CFun "product" [genConstraintPExp a]
+        | otherwise = error "Choco: Unexpected product argument."
+    genConstraintExp (IFunExp "+" args') =
+        CFun (if _iType (head args') == Just TString then "concat" else "add") (map genConstraintPExp args')
+    genConstraintExp (IFunExp op' args') =
+        CFun (mapFunc op') (map genArg args')
+        where
+            -- noclafer, the empty set, is an empty constant of the type of a set beside it, e.g.,
+            -- constant(c0_a) in if some extra then a else noclafer
+            genArg a
+                | isNoClafer a = emptyOf $ listToMaybe $ mapMaybe claferOf $ filter (not . isNoClafer) args'
+                | otherwise    = genConstraintPExp a
+    -- noclafer alone, e.g., #noclafer
+    genConstraintExp IClaferId{_sident = "noclafer"} = emptyOf Nothing
+    genConstraintExp IClaferId{_sident = "this"} = CThis
+    genConstraintExp IClaferId{_sident}
+        | isJust $ findIClafer uidIClaferMap' _sident = CGlobal _sident
+        | otherwise                = CName _sident
+    genConstraintExp (IInt val) = CInt val
+    genConstraintExp (IStr val) = CStr val
+    genConstraintExp (IDouble val) = CDouble val
+    genConstraintExp (IDecimal val) = CDecimal $ genDecimal val
+    genConstraintExp (IReal _) = error "no real numbers allowed"
+
+    mapFunc "!" = "not"
+    mapFunc "#" = "card"
+    mapFunc "min" = "minimum"
+    mapFunc "max" = "maximum"
+    mapFunc "<=>" = "ifOnlyIf"
+    mapFunc "=>" = "implies"
+    mapFunc "||" = "or"
+    mapFunc "xor" = "xor"
+    mapFunc "&&" = "and"
+    mapFunc "<" = "lessThan"
+    mapFunc ">" = "greaterThan"
+    mapFunc "=" = "equal"
+    mapFunc "<=" = "lessThanEqual"
+    mapFunc ">=" = "greaterThanEqual"
+    mapFunc "!=" = "notEqual"
+    mapFunc "in" = "$in"
+    mapFunc "not in" = "notIn"
+    mapFunc "+" = "add"
+    mapFunc "*" = "mul"
+    mapFunc "/" = "div"
+    mapFunc "%" = "mod"
+    mapFunc "++" = "union"
+    mapFunc "--" = "diff"
+    mapFunc "**" = "inter"
+    mapFunc "ifthenelse" = "ifThenElse"
+    -- the temporal operators, which chocosolver does not solve, by their names
+    mapFunc op' | op' `elem` ltlOps = op'
+    mapFunc op' = error $ "Choco: Unknown op: " ++ op'
diff --git a/src/Language/Clafer/Generator/Explicit.hs b/src/Language/Clafer/Generator/Explicit.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Clafer/Generator/Explicit.hs
@@ -0,0 +1,203 @@
+{-# LANGUAGE NamedFieldPuns #-}
+{-
+ Copyright (C) 2026 Michal Antkiewicz <http://gsd.uwaterloo.ca>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-}
+-- | Generates the explicit form of a model: the Clafer model the
+--   <https://github.com/gsdlab/chocosolver Chocosolver> solves, with nothing left implicit, and
+--   its scope file (@clafer -m clafer@, @--meta-data@).
+module Language.Clafer.Generator.Explicit (genExplicitModule) where
+
+import Data.List
+import qualified Data.Map as Map
+import Data.Maybe
+import Language.Clafer.Common
+import Language.Clafer.Generator.ChocoModel
+import Language.Clafer.Intermediate.Intclafer
+
+-- | The explicit form of the model chocosolver solves, and its scope file: a Clafer model with
+--   every name a UID, every card, group card, this, parent and dref written out, which starts
+--   with @\/\/# OPTIONS --explicit@ (i.e., -f -k -l --ss=none) and compiles to itself; and
+--   every scope, as chocosolver's @AstPrinter@ and @ScopeFile@ print them. The [choco| |]
+--   escapes, which are JavaScript, are left out.
+--   A temporal model has its temporal modifiers and operators, which chocosolver does not
+--   read, and its trace length among the options.
+genExplicitModule :: (IModule, GEnv) -> [(UID, Integer)] -> (Maybe Integer, Maybe Integer) -> Maybe Integer -> Maybe Integer -> (Result, String)
+genExplicitModule ir scopes intRange decimalDigits traceLength =
+    let model = chocoModel ir scopes intRange decimalDigits []
+    in (explicitModel traceLength model, explicitScopes model)
+
+-- | The explicit model, with the trace length of a temporal model
+explicitModel :: Maybe Integer -> CModel -> Result
+explicitModel traceLength CModel{cmElements} =
+    -- the model declares itself explicit, for clafer and chocosolver
+    "//# OPTIONS --explicit" ++ maybe "" (\tl -> " --tl=" ++ show tl) traceLength ++ "\n"
+    ++ concat [ "[" ++ exExp e ++ "]\n" | CEConstraint e <- cmElements ]
+    ++ concat [ exClafer superMap "" c | CEClafer c <- cmElements ]
+    ++ (if null objectives && null assertions then "" else "\n")
+    ++ concat [ "<< " ++ (if isMax then "max " else "min ") ++ exExp e ++ " >>\n" | (isMax, e) <- objectives ]
+    ++ concat [ "assert [" ++ exExp e ++ "]\n" | e <- assertions ]
+  where
+    allElements = concatMap preOrder cmElements
+    preOrder e@(CEClafer c) = e : concatMap preOrder (ccElements c)
+    preOrder e = [e]
+    objectives = [ (isMax, e) | CEObjective isMax e <- allElements ]
+    assertions = [ e | CEAssert e <- allElements ]
+    superMap = Map.fromList [ (ccUid c, c) | CEClafer c <- allElements ]
+
+-- | A clafer with its block: its group card (its own, otherwise its super clafer's, which it
+--   inherits), its super clafer, its own reference, its card (0..* if abstract), then its
+--   constraints and children
+exClafer :: Map.Map UID CClafer -> String -> CClafer -> Result
+exClafer superMap indent CClafer{ccUid, ccAbstract, ccModifiers, ccCard, ccGCard, ccSuper, ccRef, ccRefConstraints, ccElements} =
+    indent
+    ++ (if ccAbstract then "abstract " else "")
+    ++ concatMap (++ " ") ccModifiers
+    ++ exCard (inheritedGCard ccGCard ccSuper) ++ " "
+    ++ ccUid
+    ++ maybe "" (" : " ++) ccSuper
+    ++ maybe "" (\(isSet', target) -> (if isSet' then " -> " else " ->> ") ++ exTarget target) ccRef
+    ++ " " ++ (if ccAbstract then "0..*" else exCard ccCard)
+    ++ (if null constraints && null subClafers then " {}\n"
+        else " {\n"
+             ++ concat [ indent' ++ "[" ++ exExp e ++ "]\n" | e <- constraints ]
+             ++ concatMap (exClafer superMap indent') subClafers
+             ++ indent ++ "}\n")
+  where
+    indent' = indent ++ "  "
+    constraints = ccRefConstraints ++ [ e | CEConstraint e <- ccElements ]
+    subClafers = [ c | CEClafer c <- ccElements ]
+    inheritedGCard g@(Just _) _ = g
+    inheritedGCard Nothing (Just s) | Just CClafer{ccGCard = g, ccSuper = s'} <- Map.lookup s superMap = inheritedGCard g s'
+    inheritedGCard _ _ = Nothing
+    exTarget "integer" = "int"
+    exTarget target = target
+
+exCard :: Maybe Interval -> String
+exCard (Just (low, high)) = show low ++ ".." ++ (if high < 0 then "*" else show high)
+exCard Nothing            = "0..*"
+
+-- | An expression, fully parenthesized except for navigation, which binds tightest
+exExp :: CExp -> String
+exExp CThis = "this"
+exExp (CGlobal u) = u
+exExp (CName n) = n
+exExp (CInt val) = show val
+exExp (CStr val) = val
+exExp (CDouble val) = show val
+exExp (CDecimal val) = val
+exExp (CEmpty _) = "noclafer"
+exExp (CJoin e c) = exOperand e ++ "." ++ c
+exExp (CJoinRef e) = exOperand e ++ ".dref"
+exExp (CJoinParent e) = exOperand e ++ ".parent"
+-- chocosolver's quantifiers over a set compare its size, e.g., none(x) is #x = 0
+exExp (CQuant q [] set) = case q of
+    INo   -> sizeIs "=" 0
+    ISome -> sizeIs ">=" 1
+    ILone -> sizeIs "<=" 1
+    IOne  -> sizeIs "=" 1
+    IAll  -> "all " ++ exOperand set
+  where
+    sizeIs op' n = "(#" ++ exOperand set ++ ") " ++ op' ++ " " ++ show (n :: Integer)
+exExp (CQuant q decls' body') = exQuant q ++ " " ++ intercalate ", " (map exDecl decls') ++ " | " ++ exExp body'
+  where
+    exDecl (CDecl isDisj' locals set) = (if isDisj' then "disj " else "") ++ intercalate "; " locals ++ " : " ++ exExp set
+exExp (CFun f args') = case (f, args') of
+    ("not", [a])       -> "!" ++ exOperand a
+    -- -1 is a constant, so the negation of a number is -(1)
+    ("minus", [a])     -> "-" ++ (if isConstant a then "(" ++ exExp a ++ ")" else exOperand a)
+    ("card", [a])      -> "#" ++ exOperand a
+    ("sum", [a])       -> "sum " ++ exOperand a ++ ".dref"
+    ("product", [a])   -> "product " ++ exOperand a ++ ".dref"
+    ("maximum", [a])   -> "max " ++ exOperand a
+    ("minimum", [a])   -> "min " ++ exOperand a
+    ("concat", [a, b]) -> "concat(" ++ exExp a ++ ", " ++ exExp b ++ ")"
+    ("ifThenElse", [a, b, c]) -> "if " ++ exOperand a ++ " then " ++ exOperand b ++ " else " ++ exOperand c
+    -- the temporal operators F, G, X, initially and finally; U and W are binary operators
+    (_, [a]) | f `elem` ltlUnOps -> f ++ " " ++ exOperand a
+    (_, [a, b]) | Just op' <- lookup f binaryOps -> exOperand a ++ " " ++ op' ++ " " ++ exOperand b
+    _ -> error $ "Choco: no explicit form of " ++ f
+  where
+    isConstant CInt{} = True
+    isConstant CDecimal{} = True
+    isConstant CEmpty{} = True
+    isConstant _ = False
+    binaryOps =
+        [ ("add", "+"), ("sub", "-"), ("mul", "*"), ("div", "/"), ("mod", "%")
+        , ("and", "&&"), ("or", "||"), ("implies", "=>"), ("ifOnlyIf", "<=>"), ("xor", "xor")
+        , ("lessThan", "<"), ("lessThanEqual", "<="), ("greaterThan", ">"), ("greaterThanEqual", ">=")
+        , ("equal", "="), ("notEqual", "!="), ("$in", "in"), ("notIn", "not in")
+        , ("union", "++"), ("diff", "--"), ("inter", "**"), ("U", "U"), ("W", "W") ]
+
+exQuant :: IQuant -> String
+exQuant INo = "no"
+exQuant ISome = "some"
+exQuant IAll = "all"
+exQuant IOne = "one"
+exQuant ILone = "lone"
+
+-- | An operand: navigation and atoms as they are, other expressions in parentheses
+exOperand :: CExp -> String
+exOperand e
+    | isAtom e = exExp e
+    | otherwise = "(" ++ exExp e ++ ")"
+  where
+    isAtom CThis = True
+    isAtom CGlobal{} = True
+    isAtom CName{} = True
+    isAtom CInt{} = True
+    isAtom CStr{} = True
+    isAtom CDouble{} = True
+    isAtom CDecimal{} = True
+    isAtom CEmpty{} = True
+    isAtom CJoin{} = True
+    isAtom CJoinRef{} = True
+    isAtom CJoinParent{} = True
+    isAtom (CFun "concat" _) = True
+    isAtom _ = False
+
+-- | The scope file of the explicit form: every clafer's scope by its UID, sorted, then the
+--   default scope and the ranges, as chocosolver's ScopeFile prints the scope it solves with
+explicitScopes :: CModel -> String
+explicitScopes CModel{cmElements, cmScope = CScope{csClafers, csIntRange, csStringLength, csDecimalScale}} =
+    "[\n" ++ intercalate ",\n" entries ++ "\n]\n"
+  where
+    uids = sort [ ccUid c | CEClafer c <- concatMap preOrder cmElements ]
+    preOrder e@(CEClafer c) = e : concatMap preOrder (ccElements c)
+    preOrder e = [e]
+    (intLow, intHigh) = fromMaybe (-128, 127) csIntRange
+    scale = fromMaybe 0 csDecimalScale
+    -- the largest decimal: chocosolver's Integer.MAX_VALUE / 100 - 1, scaled
+    maxScaledDecimal = 21474835 :: Integer
+    entries =
+        [ "{\"lpqName\": \"" ++ u ++ "\", \"scope\": " ++ show (fromMaybe 1 $ lookup u csClafers) ++ "}" | u <- uids ]
+        ++ [ "{\"defaultScope\": 1}"
+           , "{\"int\": [" ++ show intLow ++ ", " ++ show intHigh ++ "]}"
+           , "{\"mul\": [" ++ show intLow ++ ", " ++ show intHigh ++ "]}"
+           , "{\"stringLength\": " ++ show csStringLength ++ "}"
+           , "{\"chars\": [32, 126]}"
+           , "{\"decimalDigits\": " ++ show scale ++ "}"
+           , "{\"decimal\": [" ++ unscaled (-maxScaledDecimal) ++ ", " ++ unscaled maxScaledDecimal ++ "]}" ]
+    -- a scaled decimal as written, e.g., 214748.35 for 21474835 with 2 digits
+    unscaled n =
+        let digits = show (abs n)
+            padded = replicate (fromIntegral scale + 1 - length digits) '0' ++ digits
+            (whole, fraction) = splitAt (length padded - fromIntegral scale) padded
+        in (if n < 0 then "-" else "") ++ whole ++ (if scale > 0 then "." ++ fraction else "")
diff --git a/src/Language/Clafer/Generator/Graph.hs b/src/Language/Clafer/Generator/Graph.hs
--- a/src/Language/Clafer/Generator/Graph.hs
+++ b/src/Language/Clafer/Generator/Graph.hs
@@ -28,6 +28,7 @@
 import Language.Clafer.Intermediate.Intclafer
 import Language.Clafer.Generator.Html(genTooltip)
 import Control.Applicative
+import Data.List (find)
 import qualified Data.Map as Map
 import Data.Maybe
 import Prelude hiding (exp)
@@ -79,9 +80,9 @@
                       -> Bool
                       -> String
 -- top-level abstract and concrete
-graphSimpleClafer (Clafer s abstract gCard id' super' reference' crd init' es) (True, _, _) irMap showRefs =
+graphSimpleClafer (Clafer s abstract' tmod' gCard id' super' reference' crd init' trans es) (True, _, _) irMap showRefs =
   let
-    tooltip = genTooltip (Module s [ElementDecl s (Subclafer s (Clafer s abstract gCard id' super' reference' crd init' es))]) irMap
+    tooltip = genTooltip (Module s [ElementDecl s (Subclafer s (Clafer s abstract' tmod' gCard id' super' reference' crd init' trans es))]) irMap
     firstLineQuoted = htmlChars $ head $ lines tooltip
     tooltipQuoted = htmlChars tooltip
     uid' = getDivId s irMap
@@ -99,27 +100,25 @@
       graphSimpleReference reference' (True, Just uid', Just uid') irMap showRefs ++
       graphSimpleElements es (False, Just uid', Just uid') irMap showRefs
 -- nested abstract
-graphSimpleClafer (Clafer s abstract@(Abstract _) gCard id' super' reference' crd init' es) (False, _, _) irMap showRefs =
+graphSimpleClafer (Clafer s abstract'@(Abstract _) tmod' gCard id' super' reference' crd init' trans es) (False, _, _) irMap showRefs =
   let
-    tooltip = genTooltip (Module s [ElementDecl s (Subclafer s (Clafer s abstract gCard id' super' reference' crd init' es))]) irMap
-    firstLineQuoted = htmlChars $ head $ lines tooltip
-    tooltipQuoted = htmlChars tooltip
+    tooltip = genTooltip (Module s [ElementDecl s (Subclafer s (Clafer s abstract' tmod' gCard id' super' reference' crd init' trans es))]) irMap
     uid' = getDivId s irMap
   in
      "\"" ++
       uid' ++
       "\" [label=\"" ++
-      firstLineQuoted ++
+      head (lines tooltip) ++
       "\" URL=\"#" ++
       uid' ++
       "\" tooltip=\"" ++
-      tooltipQuoted ++
+      htmlChars tooltip ++
       "\"];\n" ++
       graphSimpleSuper super' (False, Just uid', Just uid') irMap showRefs ++
       graphSimpleReference reference' (False, Just uid', Just uid') irMap showRefs ++
       graphSimpleElements es (False, Just uid', Just uid') irMap showRefs
 -- nested concrete
-graphSimpleClafer (Clafer _ _ _ id' super' reference' _ _ es) topLevel irMap showRefs =
+graphSimpleClafer (Clafer _ _ _ _ id' super' reference' _ _ _ es) topLevel irMap showRefs =
   let
     (PosIdent (_,ident')) = id'
   in
@@ -173,8 +172,8 @@
        refColour showRefs ++
        " fontcolor=" ++
        refColour showRefs ++
-       (if fst3 topLevel == True then "" else " label=" ++
-       (fromJust $ trd3 topLevel)) ++
+       (if fst3 topLevel == True then "" else " label=\"" ++
+       (fromJust $ trd3 topLevel) ++ "\"") ++
        "];\n"
     _ -> ""
 graphSimpleReference (ReferenceBag _ setExp) topLevel irMap showRefs =
@@ -194,8 +193,8 @@
         refColour showRefs ++
         " fontcolor=" ++
         refColour showRefs ++
-        (if fst3 topLevel == True then "" else " label=" ++
-        (fromJust $ trd3 topLevel)) ++ "];\n")
+        (if fst3 topLevel == True then "" else " label=\"" ++
+        (fromJust $ trd3 topLevel) ++ "\"") ++ "];\n")
     _ -> ""
 refColour :: Bool -> String
 refColour True = "lightgray"
@@ -262,16 +261,16 @@
 graphCVLElements (ElementsList _ es) parent' irMap = concatMap (\x -> graphCVLElement x parent' irMap  ++ "\n") es
 
 graphCVLClafer :: Clafer -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLClafer (Clafer s _ gCard _ super' reference' crd _ es) parent' irMap
+graphCVLClafer (Clafer s _ _ gCard _ super' reference' crd _ _ es) parent' irMap
    = let {{-tooltip = genTooltip (Module [ElementDecl (Subclafer (Clafer abstract gCard id' super' crd init' es))]) irMap;-}
           uid' = getDivId s irMap;
           gcrd = graphCVLGCard gCard parent' irMap;
           super'' = graphCVLSuper super' parent' irMap;
           reference'' = graphCVLReference reference' parent' irMap} in
-     "\"" ++ uid' ++ "\" [URL=\"#" ++ uid' ++ "\" label=\"" ++ dropUid uid' ++ super'' ++ reference'' ++ (if choiceCard crd then "\" style=rounded"  else " [" ++ graphCVLCard crd parent' irMap ++ "]\"")
+     "\"" ++ uid' ++ "\" [URL=\"#" ++ uid' ++ "\" label=\"" ++ nameIn irMap uid' ++ super'' ++ reference'' ++ (if choiceCard crd then "\" style=rounded"  else " [" ++ graphCVLCard crd parent' irMap ++ "]\"")
      ++ (if super'' == "" then "" else " shape=oval") ++ "];\n"
-     ++ (if gcrd == "" then "" else "g" ++ uid' ++ " [label=\"" ++ gcrd ++ "\" fontsize=10 shape=triangle];\ng" ++ uid' ++ " -> " ++ uid' ++ " [weight=10];\n")
-     ++ (if parent'==Nothing then "" else uid' ++ " -> " ++ fromJust parent' ++ (if lowerCard crd == "0" then " [style=dashed]" else "") ++ ";\n")
+     ++ (if gcrd == "" then "" else "\"g" ++ uid' ++ "\" [label=\"" ++ gcrd ++ "\" fontsize=10 shape=triangle];\n\"g" ++ uid' ++ "\" -> \"" ++ uid' ++ "\" [weight=10];\n")
+     ++ (if parent'==Nothing then "" else "\"" ++ uid' ++ "\" -> \"" ++ fromJust parent' ++ "\"" ++ (if lowerCard crd == "0" then " [style=dashed]" else "") ++ ";\n")
      ++ graphCVLElements es (if gcrd == "" then (Just uid') else (Just $ "g" ++ uid')) irMap
 
 graphCVLSuper :: Super -> Maybe String -> Map.Map Span [Ir] -> String
@@ -377,12 +376,12 @@
 lowerCard crd = takeWhile (/= '.') $ graphCVLCard crd Nothing Map.empty
 
 --Miscellaneous functions
-dropUid :: String -> String
-dropUid uid' = let id' = rest $ dropWhile (\x -> x /= '_') uid' in if id' == "" then uid' else id'
-
-rest :: String -> String
-rest [] = []
-rest (_:xs) = xs
+-- | The name of a clafer or local in an expression of the IR: a clafer's name (its _ident),
+--   found in the trace of the IR, whose UID need not contain it; a local's name is itself.
+nameIn :: Map.Map Span [Ir] -> String -> String
+nameIn irMap uid' = case [ _ident c | IRClafer c <- concat (Map.elems irMap), _uid c == uid' ] of
+  (name : _) -> name
+  []         -> uid'
 
 getUid :: PosIdent -> Map.Map Span [Ir] -> String
 getUid (PosIdent (pos, id')) irMap = if Map.lookup (getSpan (PosIdent (pos, id'))) irMap == Nothing
@@ -394,8 +393,8 @@
                                  getIdentIExp (IClaferId _ id'' _ _) = [id''];
                                  getIdentIExp (IDeclPExp _ _ pexp) = getIdentPExp pexp;
                                  getIdentIExp _ = [];
-                                 findUid name (x:xs) = if name == dropUid x then x else findUid name xs;
-                                 findUid name []     = name}
+                                 findUid _    [x]    = x;
+                                 findUid name xs     = fromMaybe name $ find ((== name) . nameIn irMap) xs}
 
 getDivId :: Span -> Map.Map Span [Ir] -> String
 getDivId s irMap = if Map.lookup s irMap == Nothing
diff --git a/src/Language/Clafer/Generator/Html.hs b/src/Language/Clafer/Generator/Html.hs
--- a/src/Language/Clafer/Generator/Html.hs
+++ b/src/Language/Clafer/Generator/Html.hs
@@ -36,16 +36,19 @@
   , printStandaloneComment
   , printInlineComment
   , highlightErrors
+  , highlightErrorsIn
+  , printFileHeader
   ) where
 
 import Language.ClaferT
-import Language.Clafer.Front.AbsClafer
+import Language.Clafer.Front.AbsClafer as AbsClafer
 import Language.Clafer.Front.LayoutResolver(revertLayout)
 import Language.Clafer.Intermediate.Tracing
 import Language.Clafer.Intermediate.Intclafer
+import Language.Clafer.Import (ModelFile, modelPosition, fileStarts)
 
 import Control.Applicative
-import Data.List (intersperse,genericSplitAt)
+import Data.List (find, intersperse, genericSplitAt, nub)
 import qualified Data.Map as Map
 import Data.Maybe
 import Data.Char (isSpace)
@@ -54,32 +57,32 @@
 printPreComment :: Span -> [(Span, String)] -> ([(Span, String)], String)
 printPreComment _ [] = ([], [])
 printPreComment (Span (Pos r _) _) (c@((Span (Pos r' _) _), _):cs)
-  | r > r' = findAll r ((c:cs), [])
+  | r > r' = findAll r (c:cs, [])
   | otherwise  = (c:cs, "")
     where findAll _ ([],comments) = ([],comments)
           findAll row ((c'@((Span (Pos row' col') _), comment):cs'), comments)
             | row > row' = case take 3 comment of
-                '/':'/':'#':[] -> findAll row (cs', concat [comments, "<!-- " ++ trim (drop 2 comment) ++ " /-->\n"])
-                '/':'/':_:[]   -> if col' == 1
-                                  then findAll row (cs', concat [comments, printStandaloneComment comment ++ "\n"])
-                                  else findAll row (cs', concat [comments, printInlineComment comment ++ "\n"])
-                '/':'*':_:[]   -> findAll row (cs', concat [comments, printStandaloneComment comment ++ "\n"])
+                ['/', '/', '#'] -> findAll row (cs', concat [comments, printHtmlComment (trim (drop 2 comment)) ++ "\n"])
+                ['/', '/', _]   -> if col' == 1
+                                   then findAll row (cs', concat [comments, printStandaloneComment comment ++ "\n"])
+                                   else findAll row (cs', concat [comments, printInlineComment comment ++ "\n"])
+                ['/', '*', _]   -> findAll row (cs', concat [comments, printStandaloneComment comment ++ "\n"])
                 _      -> (cs', "")
-            | otherwise  = ((c':cs'), comments)
+            | otherwise  = (c':cs', comments)
 printComment :: Span -> [(Span, String)] -> ([(Span, String)], String)
 printComment _ [] = ([],[])
 printComment (Span (Pos row _) _) (c@(Span (Pos row' col') _, comment):cs)
   | row == row' = case take 3 comment of
-        '/':'/':'#':[] -> (cs,"<!-- " ++ trim' (drop 2 comment) ++ " /-->\n")
-        '/':'/':_:[]   -> if col' == 1
-                          then (cs, printStandaloneComment comment ++ "\n")
-                          else (cs, printInlineComment comment ++ "\n")
-        '/':'*':_:[]   -> (cs, printStandaloneComment comment ++ "\n")
+        ['/', '/', '#'] -> (cs, printHtmlComment (trim' (drop 2 comment)) ++ "\n")
+        ['/', '/', _]   -> if col' == 1
+                           then (cs, printStandaloneComment comment ++ "\n")
+                           else (cs, printInlineComment comment ++ "\n")
+        ['/', '*', _]   -> (cs, printStandaloneComment comment ++ "\n")
         _      -> (cs, "")
   | otherwise = (c:cs, "")
   where trim' = let f = reverse. dropWhile isSpace in f . f
 printStandaloneComment :: String -> String
-printStandaloneComment comment = "<div class=\"standalonecomment\">" ++ replaceNLwithBR comment ++ "</div>"
+printStandaloneComment comment = "<div class=\"standalonecomment\">" ++ replaceNLwithBR (escapeHtml comment) ++ "</div>"
   where
     replaceNLwithBR :: String   -> String
     replaceNLwithBR    ""        = ""
@@ -88,12 +91,31 @@
 
 
 printInlineComment :: String -> String
-printInlineComment comment = "<span class=\"inlinecomment\">" ++ comment ++ "</span>"
+printInlineComment comment = "<span class=\"inlinecomment\">" ++ escapeHtml comment ++ "</span>"
 
+-- | A //# comment as an HTML comment, e.g., <!-- # FRAGMENT /-->. Its text must not
+-- contain "--", which could end the HTML comment early.
+printHtmlComment :: String -> String
+printHtmlComment text = "<!-- " ++ noDoubleDash text ++ " /-->"
+  where
+    noDoubleDash ('-':'-':cs) = "- " ++ noDoubleDash ('-':cs)
+    noDoubleDash (c:cs)       = c : noDoubleDash cs
+    noDoubleDash ""           = ""
+
+-- | Escapes the text of a comment for HTML, so that it is shown as written.
+escapeHtml :: String -> String
+escapeHtml = concatMap escape
+  where
+    escape '&' = "&amp;"
+    escape '<' = "&lt;"
+    escape '>' = "&gt;"
+    escape '"' = "&quot;"
+    escape c   = [c]
+
 printDeprecated :: String -> String -> Bool -> String
-printDeprecated    s         m         html = (while html $ "<span class=\"deprecated\" title=\"" ++ "Deprecated. " ++ m ++ "\">")
+printDeprecated    s         m         html = while html ("<span class=\"deprecated\" title=\"" ++ "Deprecated. " ++ m ++ "\">")
                                               ++ s
-                                              ++ (while html "</span>")
+                                              ++ while html "</span>"
 
 -- | Generate the model as HTML document
 genHtml :: Module -> IModule -> String
@@ -107,17 +129,17 @@
 
 printModule :: Module -> Map.Map Span [Ir] -> Bool -> String
 printModule (Module _ [])     _ _ = ""
-printModule (Module s (x:xs)) irMap html = (printDeclaration x 0 irMap html []) ++ printModule (Module s xs) irMap html
+printModule (Module s (x:xs)) irMap html = printDeclaration x 0 irMap html [] ++ printModule (Module s xs) irMap html
 
 printDeclaration :: Declaration -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
 printDeclaration (EnumDecl s posIdent enumIds)  indent irMap html comments =
     preComments ++
     printIndentId 0 html ++
-    (while html "<span class=\"keyword\">") ++ "enum" ++ (while html "</span>") ++
+    while html "<span class=\"keyword\">" ++ "enum" ++ while html "</span>" ++
     " " ++
-    (printPosIdent posIdent mUid' html) ++
+    printPosIdent posIdent mUid' html ++
     " = " ++
-    (concat $ intersperse " | " (map (\x -> printEnumId x indent irMap html comments) enumIds)) ++
+    concat (intersperse " | " (map (\x -> printEnumId x indent irMap html comments) enumIds)) ++
     comment ++
     printIndentEnd html
   where
@@ -132,9 +154,9 @@
 printElement (ClaferUse s name crd es) indent irMap html comments =
   preComments ++
   printIndentId indent html ++
-  "`" ++ (while html ("<a href=\"#" ++ superId ++ "\"><span class=\"reference\">")) ++
+  "`" ++ while html ("<a href=\"#" ++ superId ++ "\"><span class=\"reference\">") ++
   printName name indent irMap False [] --trick the printer into only printing the name
-  ++ (while html "</span></a>") ++
+  ++ while html "</span></a>" ++
   printCard crd ++
   comment ++
   printIndentEnd html ++
@@ -178,9 +200,10 @@
 printElements (ElementsEmpty _) _ _ _ _ = ""
 printElements (ElementsList _ es) indent irMap html comments = "\n{" ++ mapElements es indent irMap html comments ++ "\n}"
     where mapElements []     _ _ _ _ = []
-          mapElements (e':es') indent' irMap' html' comments' = if span' e' == noSpan
-                                                          then (printElement e' (indent' + 1) irMap' html' comments' {-++ "\n"-}) ++ mapElements es' indent' irMap' html' comments'
-                                                          else (printElement e' (indent' + 1) irMap' html' comments' {-++ "\n"-}) ++ mapElements es' indent' irMap' html' (afterSpan (span' e') comments')
+          mapElements (e':es') indent' irMap' html' comments'
+            = if span' e' == noSpan
+              then printElement e' (indent' + 1) irMap' html' comments' {-++ "\n"-} ++ mapElements es' indent' irMap' html' comments'
+              else printElement e' (indent' + 1) irMap' html' comments' {-++ "\n"-} ++ mapElements es' indent' irMap' html' (afterSpan (span' e') comments')
           afterSpan s comments' = let (Span _ (Pos line _)) = s in dropWhile (\(x, _) -> let (Span _ (Pos line' _)) = x in line' <= line) comments'
           span' (Subclafer s _) = s
           span' (Subconstraint s _) = s
@@ -189,7 +212,7 @@
           span' (SubAssertion s _) = s
 
 printClafer :: Clafer -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printClafer (Clafer s abstract gCard id' super' reference' crd init' es) indent irMap html comments =
+printClafer (Clafer s abstract' tmod' gCard id' super' reference' crd init' trans' es) indent irMap html comments =
   preComments ++
   printIndentId indent html ++
   claferDeclaration ++
@@ -201,37 +224,47 @@
     (comments', preComments) = printPreComment s comments;
     (comments'', comment) = printComment s comments'
     claferDeclaration = concat [
-      printAbstract abstract html,
+      printAbstract abstract' html,
+      printModifiers tmod' html,
       printGCard gCard html,
       printPosIdent id' (Just uid') html,
       printSuper super' indent irMap html comments,
       printReference reference' indent irMap html comments,
       printCard crd,
-      printInit init' indent irMap html comments]
+      printInit init' indent irMap html comments,
+      printTransition trans' indent irMap html comments]
 
 printGoal :: Goal -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
 printGoal goal indent irMap html comments =
   (if html then "&lt;&lt;" else "<<") ++
   (case goal of
-    (GoalMinimize _ exps') -> (while html "<span class=\"keyword\">") ++ "minimize" ++ (while html "</span>") ++ " " ++ concatMap (\x -> printExp x indent irMap html comments) exps'
-    (GoalMaximize _ exps') -> (while html "<span class=\"keyword\">") ++ "maximize" ++ (while html "</span>") ++ " " ++ concatMap (\x -> printExp x indent irMap html comments) exps'
+    (GoalMinimize _ exps') -> while html "<span class=\"keyword\">" ++ "minimize " ++ while html "</span>" ++ concatMap (\x -> printExp x indent irMap html comments) exps'
+    (GoalMaximize _ exps') -> while html "<span class=\"keyword\">" ++ "maximize " ++ while html "</span>" ++ concatMap (\x -> printExp x indent irMap html comments) exps'
     (GoalMinDeprecated _ exps') -> printDeprecated "min " "Use `minimize` instead." html ++ concatMap (\x -> printExp x indent irMap html comments) exps'
     (GoalMaxDeprecated _ exps') -> printDeprecated "max " "Use `maximize` instead." html ++ concatMap (\x -> printExp x indent irMap html comments) exps'
   ) ++
   if html then "&gt;&gt;" else ">>"
 
 printAbstract :: Abstract -> Bool -> String
-printAbstract (Abstract _) html   = (while html "<span class=\"keyword\">") ++ "abstract" ++ (while html "</span>") ++ " "
+printAbstract (Abstract _) html   = while html "<span class=\"keyword\">" ++ "abstract" ++ while html "</span>" ++ " "
 printAbstract (AbstractEmpty _) _ = ""
 
+printModifiers :: [TempModifier] -> Bool -> String
+printModifiers tmods' html = concatMap printTempMod tmods'
+  where
+    printTempMod (AbsClafer.Final _)       = while html "<span class=\"tKeyword\">" ++ "final" ++ while html "</span>" ++ " "
+    printTempMod (AbsClafer.FinalRef _)    = while html "<span class=\"tKeyword\">" ++ "finalref" ++ while html "</span>" ++ " "
+    printTempMod (AbsClafer.FinalTarget _) = while html "<span class=\"tKeyword\">" ++ "finaltarget" ++ while html "</span>" ++ " "
+    printTempMod (Initial _)               = while html "<span class=\"tKeyword\">" ++ "initial" ++ while html "</span>" ++ " "
+
 printGCard :: GCard -> Bool -> String
 printGCard gCard html = case gCard of
   (GCardInterval _ ncard) -> printNCard ncard
   (GCardEmpty _)          -> ""
-  (GCardXor _)            -> (while html "<span class=\"keyword\">") ++ "xor" ++ (while html "</span>") ++ " "
-  (GCardOr _)             -> (while html "<span class=\"keyword\">") ++ "or"  ++ (while html "</span>") ++ " "
-  (GCardMux _)            -> (while html "<span class=\"keyword\">") ++ "mux" ++ (while html "</span>") ++ " "
-  (GCardOpt _)            -> (while html "<span class=\"keyword\">") ++ "opt" ++ (while html "</span>") ++ " "
+  (GCardXor _)            -> while html "<span class=\"keyword\">" ++ "xor" ++ while html "</span>" ++ " "
+  (GCardOr _)             -> while html "<span class=\"keyword\">" ++ "or"  ++ while html "</span>" ++ " "
+  (GCardMux _)            -> while html "<span class=\"keyword\">" ++ "mux" ++ while html "</span>" ++ " "
+  (GCardOpt _)            -> while html "<span class=\"keyword\">" ++ "opt" ++ while html "</span>" ++ " "
 
 printNCard :: NCard -> String
 printNCard (NCard _ (PosInteger (_, num)) exInteger) = num ++ ".." ++ printExInteger exInteger ++ " "
@@ -248,17 +281,17 @@
 
 printPosIdent :: PosIdent -> Maybe String -> Bool -> String
 printPosIdent (PosIdent (_, id')) Nothing _ = id'
-printPosIdent (PosIdent (_, id')) (Just uid') html = (while html $ "<span class=\"claferDecl\" id=\"" ++ uid' ++ "\">") ++ id' ++ (while html "</span>")
+printPosIdent (PosIdent (_, id')) (Just uid') html = while html ("<span class=\"claferDecl\" id=\"" ++ uid' ++ "\">") ++ id' ++ while html "</span>"
 
 printPosIdentRef :: PosIdent -> Map.Map Span [Ir] -> Bool -> String
 printPosIdentRef (PosIdent (_, "dref")) _ html
-  = (while html "<span class=\"keyword\">") ++ "dref" ++ (while html "</span>")
+  = while html "<span class=\"keyword\">" ++ "dref" ++ while html "</span>"
 printPosIdentRef (PosIdent (_, "this")) _ html
-  = (while html "<span class=\"keyword\">") ++ "this" ++ (while html "</span>")
+  = while html "<span class=\"keyword\">" ++ "this" ++ while html "</span>"
 printPosIdentRef (PosIdent (_, "parent")) _ html
-  = (while html "<span class=\"keyword\">") ++ "parent" ++ (while html "</span>")
+  = while html "<span class=\"keyword\">" ++ "parent" ++ while html "</span>"
 printPosIdentRef (PosIdent (_, "root")) _ html
-  = (while html "<span class=\"keyword\">") ++ "root" ++ (while html "</span>")
+  = while html "<span class=\"keyword\">" ++ "root" ++ while html "</span>"
 printPosIdentRef (PosIdent (_, "ref")) _ html
   = printDeprecated "ref" "Use `dref` instead." html
 printPosIdentRef (PosIdent (_, id')) _     False = id'
@@ -271,12 +304,27 @@
 
 printSuper :: Super -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
 printSuper (SuperEmpty _) _ _ _ _ = ""
-printSuper (SuperSome _ setExp) indent irMap html comments = (while html "<span class=\"keyword\">") ++ " : " ++ (while html "</span>") ++ printExp setExp indent irMap html comments
+printSuper (SuperSome _ setExp) indent irMap html comments = while html "<span class=\"keyword\">" ++ " : " ++ while html "</span>" ++ case setExp of
+  -- a path, e.g., `Person.Head`, resolves as a whole to the clafer it names: its last name
+  -- links to that clafer
+  -- links to that clafer, and each name before it to the clafer with the name if only one has it
+  EJoin s left (ClaferId _ (Path _ [ModIdIdent _ (PosIdent (_, n))])) | html, Just uid' <- uidAt s ->
+    printPrefix left ++ "." ++ link uid' n
+  _ -> printOperand 26 setExp indent irMap html comments
+  where
+    uidAt s = listToMaybe [ u | IRPExp PExp{_exp = IClaferId{_sident = u}} <- fromMaybe [] $ Map.lookup s irMap ]
+    link uid' n = "<a href=\"#" ++ uid' ++ "\"><span class=\"reference\">" ++ n ++ "</span></a>"
+    printPrefix (EJoin _ l r) = printPrefix l ++ "." ++ printPrefix r
+    printPrefix e@(ClaferId _ (Path _ [ModIdIdent _ (PosIdent (_, n))])) =
+      case nub [ _uid c | IRClafer c <- concat (Map.elems irMap), _ident c == n ] of
+        [uid'] -> link uid' n
+        _      -> printOperand 27 e indent irMap html comments
+    printPrefix e = printOperand 27 e indent irMap html comments
 
 printReference :: Reference -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
 printReference (ReferenceEmpty _) _ _ _ _ = ""
-printReference (ReferenceSet _ setExp) indent irMap html comments = (while html "<span class=\"keyword\">") ++ " -> " ++ (while html "</span>") ++ printExp setExp indent irMap html comments
-printReference (ReferenceBag _ setExp) indent irMap html comments = (while html "<span class=\"keyword\">") ++ " ->> " ++ (while html "</span>") ++ printExp setExp indent irMap html comments
+printReference (ReferenceSet _ setExp) indent irMap html comments = while html "<span class=\"keyword\">" ++ " -> " ++ while html "</span>" ++ printOperand 23 setExp indent irMap html comments
+printReference (ReferenceBag _ setExp) indent irMap html comments = while html "<span class=\"keyword\">" ++ " ->> " ++ while html "</span>" ++ printOperand 23 setExp indent irMap html comments
 
 
 printCard :: Card -> String
@@ -288,7 +336,7 @@
 printCard (CardInterval _ nCard) = " " ++ printNCard nCard
 
 printConstraint ::  Constraint -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printConstraint (Constraint _ exps') indent irMap html comments = (concatMap (\x -> printConstraint' x indent irMap html comments) exps')
+printConstraint (Constraint _ exps') indent irMap html comments = concatMap (\x -> printConstraint' x indent irMap html comments) exps'
 
 printConstraint' :: Exp -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
 printConstraint' exp' indent irMap html comments =
@@ -310,12 +358,21 @@
 
 printDecl :: Decl-> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
 printDecl (Decl _ locids setExp) indent irMap html comments =
-  (concat $ intersperse "; " $ map printLocId locids) ++
-  (while html "<span class=\"keyword\">") ++ " : " ++ (while html "</span>") ++ printExp setExp indent irMap html comments
+  concat (intersperse "; " $ map printLocId locids) ++
+  while html "<span class=\"keyword\">" ++ " : " ++ while html "</span>" ++ printOperand 21 setExp indent irMap html comments
   where
     printLocId :: LocId -> String
     printLocId (LocIdIdent _ (PosIdent (_, ident'))) = ident'
 
+printVarBinding :: VarBinding-> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
+printVarBinding (VarBinding _ locid exp') indent irMap html comments =
+  printLocId locid ++
+  while html "<span class=\"keyword\">" ++ " = " ++ while html "</span>" ++
+  printOperand 16 exp' indent irMap html comments
+  where
+    printLocId :: LocId -> String
+    printLocId (LocIdIdent _ (PosIdent (_, ident'))) = ident'
+
 printInit :: Init -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
 printInit (InitEmpty _) _ _ _ _ = ""
 printInit (InitSome _ initHow exp') indent irMap html comments = printInitHow initHow  ++ printExp exp' indent irMap html comments
@@ -324,59 +381,177 @@
 printInitHow (InitConstant _) = " = "
 printInitHow (InitDefault _) = " := "
 
+printTransition :: Transition -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
+printTransition (TransitionEmpty _) _ _ _ _ = ""
+printTransition (Transition _ (SyncTransArrow _) exp2) indent irMap html comments = (if html then "<span class=\"tKeyword\"> --&gt;&gt; </span>" else " -->> ") ++ printExp exp2 indent irMap html comments
+printTransition (Transition _ (NextTransArrow _) exp2) indent irMap html comments = (if html then "<span class=\"tKeyword\"> --&gt; </span>" else " --> ") ++ printExp exp2 indent irMap html comments
+printTransition (Transition _ (GuardedSyncTransArrow _ (TransGuard _ guardExp)) exp2) indent irMap html comments = while html "<span class=\"tKeyword\">" ++ " -[" ++ while html "</span>" ++ printOperand 1 guardExp indent irMap html comments ++ (if html then "<span class=\"tKeyword\">]-&gt;&gt; </span>" else "]->> ")  ++ printExp exp2 indent irMap html comments
+printTransition (Transition _ (GuardedNextTransArrow _ (TransGuard _ guardExp)) exp2) indent irMap html comments = while html "<span class=\"tKeyword\">" ++ " -[" ++ while html "</span>" ++ printOperand 1 guardExp indent irMap html comments ++ (if html then "<span class=\"tKeyword\">]-&gt; </span>" else "]-> ") ++ printExp exp2 indent irMap html comments
+
 printExp :: Exp -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printExp (EDeclAllDisj _ decl exp') indent irMap html comments = "all disj " ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
-printExp (EDeclAll _     decl exp') indent irMap html comments = "all " ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
-printExp (EDeclQuantDisj _ quant' decl exp') indent irMap html comments = (printQuant quant' html) ++ "disj" ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
-printExp (EDeclQuant _     quant' decl exp') indent irMap html comments = (printQuant quant' html) ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
-printExp (EGMax _ exp')            indent irMap html comments = "max " ++ printExp exp' indent irMap html comments
-printExp (EGMin _ exp')            indent irMap html comments = "min " ++ printExp exp' indent irMap html comments
-printExp (ENeq _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " != " ++ (printExp exp'2 indent irMap html comments)
-printExp (EQuantExp _ quant' exp')   indent irMap html comments = printQuant quant' html ++ printExp exp' indent irMap html comments
-printExp (EImplies _ exp'1 exp'2)   indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " =&gt; " else " => ") ++ printExp exp'2 indent irMap html comments
-printExp (EAnd _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &amp;&amp; " else " && ")  ++ printExp exp'2 indent irMap html comments
-printExp (EOr _ exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &#124;&#124; " else " || ") ++ printExp exp'2 indent irMap html comments
-printExp (EXor _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " xor " ++ printExp exp'2 indent irMap html comments
-printExp (ENeg _ exp')             indent irMap html comments = " ! " ++ printExp exp' indent irMap html comments
-printExp (ELt _ exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &lt; " else " < ") ++ printExp exp'2 indent irMap html comments
-printExp (EGt _ exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &gt; " else " > ") ++ printExp exp'2 indent irMap html comments
-printExp (EEq _ exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " = " ++ printExp exp'2 indent irMap html comments
-printExp (ELte _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &lt;= " else " <= ") ++ printExp exp'2 indent irMap html comments
-printExp (EGte _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &gt;= " else " >= ") ++ printExp exp'2 indent irMap html comments
-printExp (EIn _ exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " in " ++ printExp exp'2 indent irMap html comments
-printExp (ENin _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " not in " ++ printExp exp'2 indent irMap html comments
-printExp (EIff _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &lt;=&gt; " else " <=> ") ++ printExp exp'2 indent irMap html comments
-printExp (EAdd _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " + " ++ printExp exp'2 indent irMap html comments
-printExp (ESub _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " - " ++ printExp exp'2 indent irMap html comments
-printExp (EMul _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " * " ++ printExp exp'2 indent irMap html comments
-printExp (EDiv _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &#47; " else " / ") ++ printExp exp'2 indent irMap html comments
-printExp (ERem _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &#37; " else " % ") ++ printExp exp'2 indent irMap html comments
-printExp (ESum _ exp')        indent irMap html comments = "sum " ++ printExp exp' indent irMap html comments
-printExp (EProd _ exp')       indent irMap html comments = "product " ++ printExp exp' indent irMap html comments
-printExp (ECard _ exp')         indent irMap html comments = "# " ++ printExp exp' indent irMap html comments
-printExp (EMinExp _ exp')          indent irMap html comments = "-" ++ printExp exp' indent irMap html comments
-printExp (EImpliesElse _ exp'1 exp'2 exp'3) indent irMap html comments = "if " ++ (printExp exp'1 indent irMap html comments) ++ " then " ++ (printExp exp'2 indent irMap html comments) ++ " else " ++ (printExp exp'3 indent irMap html comments)
-printExp (ClaferId _ name) indent irMap html comments = printName name indent irMap html comments
-printExp (EUnion _ set1 set2) indent irMap html comments = (printExp set1 indent irMap html comments) ++ "++" ++ (printExp set2 indent irMap html comments)
-printExp (EUnionCom _ set1 set2) indent irMap html comments = (printExp set1 indent irMap html comments) ++ ", " ++ (printExp set2 indent irMap html comments)
-printExp (EDifference _ set1 set2) indent irMap html comments = (printExp set1 indent irMap html comments) ++ "--" ++ (printExp set2 indent irMap html comments)
-printExp (EIntersection _ set1 set2) indent irMap html comments = (printExp set1 indent irMap html comments) ++ "**" ++ (printExp set2 indent irMap html comments)
-printExp (EIntersectionDeprecated _ set1 set2) indent irMap html comments = (printExp set1 indent irMap html comments) ++ printDeprecated "&amp;" "Use `**` instead." html ++ (printExp set2 indent irMap html comments)
-printExp (EDomain _ set1 set2) indent irMap html comments = (printExp set1 indent irMap html comments) ++ "<:" ++ (printExp set2 indent irMap html comments)
-printExp (ERange _ set1 set2) indent irMap html comments = (printExp set1 indent irMap html comments) ++ ":>" ++ (printExp set2 indent irMap html comments)
-printExp (EJoin _ set1 set2) indent irMap html comments = (printExp set1 indent irMap html comments) ++ "." ++ (printExp set2 indent irMap html comments)
+printExp (TransitionExp _ exp1 (SyncTransArrow _) exp2) indent irMap html comments = printOperand 1 exp1 indent irMap html comments ++ (if html then "<span class=\"tKeyword\"> --&gt;&gt; </span>" else " -->> ") ++ printOperand 0 exp2 indent irMap html comments
+printExp (TransitionExp _ exp1 (NextTransArrow _) exp2) indent irMap html comments = printOperand 1 exp1 indent irMap html comments ++ (if html then "<span class=\"tKeyword\"> --&gt; </span>" else " --> ") ++ printOperand 0 exp2 indent irMap html comments
+printExp (TransitionExp _ exp1 (GuardedSyncTransArrow _ (TransGuard _ guardExp)) exp2) indent irMap html comments = printOperand 1 exp1 indent irMap html comments ++ while html "<span class=\"tKeyword\">" ++ " -[" ++ while html "</span>" ++ printOperand 1 guardExp indent irMap html comments ++ (if html then "<span class=\"tKeyword\">]-&gt;&gt; </span>" else "]->> ")  ++ printOperand 0 exp2 indent irMap html comments
+printExp (TransitionExp _ exp1 (GuardedNextTransArrow _ (TransGuard _ guardExp)) exp2) indent irMap html comments = printOperand 1 exp1 indent irMap html comments ++ while html "<span class=\"tKeyword\">" ++ " -[" ++ while html "</span>" ++ printOperand 1 guardExp indent irMap html comments ++ (if html then "<span class=\"tKeyword\">]-&gt; </span>" else "]-> ") ++ printOperand 0 exp2 indent irMap html comments
+printExp (EDeclAllDisj _ decl exp') indent irMap html comments = "all disj " ++ printDecl decl indent irMap html comments ++ " | " ++ printOperand 1 exp' indent irMap html comments
+printExp (EDeclAll _     decl exp') indent irMap html comments = "all " ++ printDecl decl indent irMap html comments ++ " | " ++ printOperand 1 exp' indent irMap html comments
+printExp (EDeclQuantDisj _ quant' decl exp') indent irMap html comments = printQuant quant' html ++ "disj" ++ printDecl decl indent irMap html comments ++ " | " ++ printOperand 1 exp' indent irMap html comments
+printExp (EDeclQuant _     quant' decl exp') indent irMap html comments = printQuant quant' html ++ printDecl decl indent irMap html comments ++ " | " ++ printOperand 1 exp' indent irMap html comments
+printExp (LetExp _ varBinding exp') indent irMap html comments = while html "<span class=\"keyword\">" ++ "let " ++ while html "</span>" ++ printVarBinding varBinding indent irMap html comments ++ while html "<span class=\"keyword\">" ++ " in " ++ while html "</span>" ++ printOperand 1 exp' indent irMap html comments
+printExp (TmpPatNever _ exp' patternScope)        indent irMap html comments = while html "<span class=\"tKeyword\">" ++ "never " ++ while html "</span>" ++ printOperand 3 exp' indent irMap html comments ++ printPatternScope patternScope indent irMap html comments
+printExp (TmpPatSometime _ exp' patternScope)     indent irMap html comments = while html "<span class=\"tKeyword\">" ++ "sometime " ++ while html "</span>" ++ printOperand 3 exp' indent irMap html comments ++ printPatternScope patternScope indent irMap html comments
+printExp (TmpPatLessOrOnce _ exp' patternScope)   indent irMap html comments = while html "<span class=\"tKeyword\">" ++ "lonce " ++ while html "</span>" ++ printOperand 3 exp' indent irMap html comments ++ printPatternScope patternScope indent irMap html comments
+printExp (TmpPatAlways _ exp' patternScope)       indent irMap html comments = while html "<span class=\"tKeyword\">" ++ "always " ++ while html "</span>" ++ printOperand 3 exp' indent irMap html comments ++ printPatternScope patternScope indent irMap html comments
+printExp (TmpPatPrecede _ exp1 exp2 patternScope) indent irMap html comments = printOperand 3 exp1 indent irMap html comments ++ while html "<span class=\"tKeyword\">" ++ " must precede " ++ while html "</span>" ++ printOperand 3 exp2 indent irMap html comments ++ printPatternScope patternScope indent irMap html comments
+printExp (TmpPatFollow _ exp1 exp2 patternScope)  indent irMap html comments = printOperand 3 exp1 indent irMap html comments ++ while html "<span class=\"tKeyword\">" ++ " must follow " ++ while html "</span>" ++ printOperand 3 exp2 indent irMap html comments ++ printPatternScope patternScope indent irMap html comments
+printExp (TmpInitially _ exp')    indent irMap html comments = while html "<span class=\"tKeyword\">" ++ "initially " ++ while html "</span>" ++ printOperand 3 exp' indent irMap html comments
+printExp (TmpFinally _ exp')      indent irMap html comments = while html "<span class=\"tKeyword\">" ++ "finally " ++ while html "</span>" ++ printOperand 3 exp' indent irMap html comments
+printExp (EGMax _ exp')           indent irMap html comments = "max " ++ printOperand 20 exp' indent irMap html comments
+printExp (EGMin _ exp')           indent irMap html comments = "min " ++ printOperand 20 exp' indent irMap html comments
+printExp (ENeq _ exp1 exp2)       indent irMap html comments = printOperand 15 exp1 indent irMap html comments ++ " != " ++ printOperand 16 exp2 indent irMap html comments
+printExp (EQuantExp _ quant' exp') indent irMap html comments = printQuant quant' html ++ printOperand 20 exp' indent irMap html comments
+printExp (EIff _ exp1 exp2)       indent irMap html comments = printOperand 3 exp1 indent irMap html comments ++ (if html then " &lt;=&gt; " else " <=> ") ++ printOperand 4 exp2 indent irMap html comments
+printExp (EImplies _ exp1 exp2)   indent irMap html comments = printOperand 4 exp1 indent irMap html comments ++ (if html then " =&gt; " else " => ") ++ printOperand 5 exp2 indent irMap html comments
+printExp (EAnd _ exp1 exp2)       indent irMap html comments = printOperand 7 exp1 indent irMap html comments ++ (if html then " &amp;&amp; " else " && ")  ++ printOperand 8 exp2 indent irMap html comments
+printExp (EOr _ exp1 exp2)        indent irMap html comments = printOperand 5 exp1 indent irMap html comments ++ (if html then " &#124;&#124; " else " || ") ++ printOperand 6 exp2 indent irMap html comments
+printExp (EXor _ exp1 exp2)       indent irMap html comments = printOperand 6 exp1 indent irMap html comments ++ " xor " ++ printOperand 7 exp2 indent irMap html comments
+printExp (LtlU _ exp1 exp2)       indent irMap html comments = printOperand 8 exp1 indent irMap html comments ++ " U " ++ printOperand 9 exp2 indent irMap html comments
+printExp (TmpUntil _ exp1 exp2)   indent irMap html comments = printOperand 8 exp1 indent irMap html comments ++ while html "<span class=\"tKeyword\">" ++ " until " ++ while html "</span>" ++ printOperand 9 exp2 indent irMap html comments
+printExp (LtlW _ exp1 exp2)       indent irMap html comments = printOperand 9 exp1 indent irMap html comments ++ " W " ++ printOperand 10 exp2 indent irMap html comments
+printExp (TmpWUntil _ exp1 exp2)  indent irMap html comments = printOperand 9 exp1 indent irMap html comments ++ while html "<span class=\"tKeyword\">" ++ " weakuntil " ++ while html "</span>" ++ printOperand 10 exp2 indent irMap html comments
+printExp (LtlF _ exp')            indent irMap html comments = "F " ++ printOperand 10 exp' indent irMap html comments
+printExp (TmpEventually _ exp')   indent irMap html comments = while html "<span class=\"tKeyword\">" ++ "eventually " ++ while html "</span>" ++ printOperand 10 exp' indent irMap html comments
+printExp (LtlG _ exp')            indent irMap html comments = "G " ++ printOperand 10 exp' indent irMap html comments
+printExp (TmpGlobally _ exp')     indent irMap html comments = while html "<span class=\"tKeyword\">" ++ "globally " ++ while html "</span>" ++ printOperand 10 exp' indent irMap html comments
+printExp (LtlX _ exp')            indent irMap html comments = "X " ++ printOperand 10 exp' indent irMap html comments
+printExp (TmpNext _ exp')         indent irMap html comments = while html "<span class=\"tKeyword\">" ++ "next " ++ while html "</span>" ++ printOperand 10 exp' indent irMap html comments
+printExp (ENeg _ exp')            indent irMap html comments = " ! " ++ printOperand 11 exp' indent irMap html comments
+printExp (ELt _ exp1 exp2)        indent irMap html comments = printOperand 15 exp1 indent irMap html comments ++ (if html then " &lt; " else " < ") ++ printOperand 16 exp2 indent irMap html comments
+printExp (EGt _ exp1 exp2)        indent irMap html comments = printOperand 15 exp1 indent irMap html comments ++ (if html then " &gt; " else " > ") ++ printOperand 16 exp2 indent irMap html comments
+printExp (EEq _ exp1 exp2)        indent irMap html comments = printOperand 15 exp1 indent irMap html comments ++ " = " ++ printOperand 16 exp2 indent irMap html comments
+printExp (ELte _ exp1 exp2)       indent irMap html comments = printOperand 15 exp1 indent irMap html comments ++ (if html then " &lt;= " else " <= ") ++ printOperand 16 exp2 indent irMap html comments
+printExp (EGte _ exp1 exp2)       indent irMap html comments = printOperand 15 exp1 indent irMap html comments ++ (if html then " &gt;= " else " >= ") ++ printOperand 16 exp2 indent irMap html comments
+printExp (EIn _ exp1 exp2)        indent irMap html comments = printOperand 15 exp1 indent irMap html comments ++ " in " ++ printOperand 16 exp2 indent irMap html comments
+printExp (ENin _ exp1 exp2)       indent irMap html comments = printOperand 15 exp1 indent irMap html comments ++ " not in " ++ printOperand 16 exp2 indent irMap html comments
+printExp (EAdd _ exp1 exp2)       indent irMap html comments = printOperand 17 exp1 indent irMap html comments ++ " + " ++ printOperand 18 exp2 indent irMap html comments
+printExp (ESub _ exp1 exp2)       indent irMap html comments = printOperand 17 exp1 indent irMap html comments ++ " - " ++ printOperand 18 exp2 indent irMap html comments
+printExp (EMul _ exp1 exp2)       indent irMap html comments = printOperand 18 exp1 indent irMap html comments ++ " * " ++ printOperand 19 exp2 indent irMap html comments
+printExp (EDiv _ exp1 exp2)       indent irMap html comments = printOperand 18 exp1 indent irMap html comments ++ (if html then " &#47; " else " / ") ++ printOperand 19 exp2 indent irMap html comments
+printExp (ERem _ exp1 exp2)       indent irMap html comments = printOperand 18 exp1 indent irMap html comments ++ (if html then " &#37; " else " % ") ++ printOperand 19 exp2 indent irMap html comments
+printExp (ESum _ exp')            indent irMap html comments = while html "<span class=\"keyword\">" ++ "sum " ++ while html "</span>" ++ printOperand 21 exp' indent irMap html comments
+printExp (EProd _ exp')           indent irMap html comments = while html "<span class=\"keyword\">" ++ "product " ++ while html "</span>" ++ printOperand 21 exp' indent irMap html comments
+printExp (ECard _ exp')           indent irMap html comments = "# " ++ printOperand 21 exp' indent irMap html comments
+printExp (EMinExp _ exp')         indent irMap html comments = "-" ++ printOperand 21 exp' indent irMap html comments
+printExp (EImpliesElse _ exp1 exp2 exp'3) indent irMap html comments
+    = while html "<span class=\"keyword\">" ++ "if " ++ while html "</span>"
+    ++ printOperand 1 exp1 indent irMap html comments
+    ++ while html "<span class=\"keyword\">" ++ " then " ++ while html "</span>"
+    ++ printOperand 1 exp2 indent irMap html comments
+    ++ while html "<span class=\"keyword\">" ++ " else " ++ while html "</span>"
+    ++ printOperand 1 exp'3 indent irMap html comments
+printExp (ClaferId _ name)           indent irMap html comments = printName name indent irMap html comments
+printExp (EUnion _ set1 set2)        indent irMap html comments = printOperand 23 set1 indent irMap html comments ++ "++" ++ printOperand 24 set2 indent irMap html comments
+printExp (EUnionCom _ set1 set2)     indent irMap html comments = printOperand 23 set1 indent irMap html comments ++ ", " ++ printOperand 24 set2 indent irMap html comments
+printExp (EDifference _ set1 set2)   indent irMap html comments = printOperand 24 set1 indent irMap html comments ++ "--" ++ printOperand 25 set2 indent irMap html comments
+printExp (EIntersection _ set1 set2) indent irMap html comments = printOperand 25 set1 indent irMap html comments ++ "**" ++ printOperand 26 set2 indent irMap html comments
+printExp (EIntersectionDeprecated _ set1 set2) indent irMap html comments = printOperand 26 set1 indent irMap html comments ++ printDeprecated "&amp;" "Use `**` instead." html ++ printOperand 27 set2 indent irMap html comments
+printExp (EDomain _ set1 set2) indent irMap html comments = printOperand 21 set1 indent irMap html comments ++ "<:" ++ printOperand 22 set2 indent irMap html comments
+printExp (ERange _ set1 set2)  indent irMap html comments = printOperand 22 set1 indent irMap html comments ++ ":>" ++ printOperand 23 set2 indent irMap html comments
+printExp (EJoin _ set1 set2)   indent irMap html comments = printOperand 26 set1 indent irMap html comments ++ "." ++ printOperand 27 set2 indent irMap html comments
 printExp (EInt _ (PosInteger (_, num))) _ _ _ _ = num
 printExp (EDouble _ (PosDouble (_, num))) _ _ _ _ = num
 printExp (EReal _ (PosReal (_, num))) _ _ _ _ = num
 printExp (EStr _ (PosString (_, str))) _ _ _ _ = str
 
+-- | Prints an operand at the precedence level that the grammar (src/clafer.cf) requires
+--   there, in parentheses when its operator binds less tightly, e.g., X (a || b)
+printOperand :: Int -> Exp -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
+printOperand level exp' indent irMap html comments
+  | expPrec exp' < level = "(" ++ printExp exp' indent irMap html comments ++ ")"
+  | otherwise            = printExp exp' indent irMap html comments
+
+-- | The precedence level of an expression in the grammar, as in Front/PrintClafer.hs
+expPrec :: Exp -> Int
+expPrec exp' = case exp' of
+  TransitionExp{}           -> 0
+  EDeclAllDisj{}            -> 1
+  EDeclAll{}                -> 1
+  EDeclQuantDisj{}          -> 1
+  EDeclQuant{}              -> 1
+  EImpliesElse{}            -> 1
+  LetExp{}                  -> 1
+  TmpPatNever{}             -> 2
+  TmpPatSometime{}          -> 2
+  TmpPatLessOrOnce{}        -> 2
+  TmpPatAlways{}            -> 2
+  TmpPatPrecede{}           -> 2
+  TmpPatFollow{}            -> 2
+  TmpInitially{}            -> 2
+  TmpFinally{}              -> 2
+  EIff{}                    -> 3
+  EImplies{}                -> 4
+  EOr{}                     -> 5
+  EXor{}                    -> 6
+  EAnd{}                    -> 7
+  LtlU{}                    -> 8
+  TmpUntil{}                -> 8
+  LtlW{}                    -> 9
+  TmpWUntil{}               -> 9
+  LtlF{}                    -> 10
+  TmpEventually{}           -> 10
+  LtlG{}                    -> 10
+  TmpGlobally{}             -> 10
+  LtlX{}                    -> 10
+  TmpNext{}                 -> 10
+  ENeg{}                    -> 11
+  ELt{}                     -> 15
+  EGt{}                     -> 15
+  EEq{}                     -> 15
+  ELte{}                    -> 15
+  EGte{}                    -> 15
+  ENeq{}                    -> 15
+  EIn{}                     -> 15
+  ENin{}                    -> 15
+  EQuantExp{}               -> 16
+  EAdd{}                    -> 17
+  ESub{}                    -> 17
+  EMul{}                    -> 18
+  EDiv{}                    -> 18
+  ERem{}                    -> 18
+  EGMax{}                   -> 19
+  EGMin{}                   -> 19
+  ESum{}                    -> 20
+  EProd{}                   -> 20
+  ECard{}                   -> 20
+  EMinExp{}                 -> 20
+  EDomain{}                 -> 21
+  ERange{}                  -> 22
+  EUnion{}                  -> 23
+  EUnionCom{}               -> 23
+  EDifference{}             -> 24
+  EIntersection{}           -> 25
+  EIntersectionDeprecated{} -> 26
+  EJoin{}                   -> 26
+  ClaferId{}                -> 27
+  EInt{}                    -> 27
+  EDouble{}                 -> 27
+  EReal{}                   -> 27
+  EStr{}                    -> 27
+
+printPatternScope :: PatternScope -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
+printPatternScope (PatScopeBefore _ exp')          indent irMap html comments = while html "<span class=\"tKeyword\">" ++ " before " ++ while html "</span>" ++ (printOperand 11 exp' indent irMap html comments)
+printPatternScope (PatScopeAfter _ exp')           indent irMap html comments = while html "<span class=\"tKeyword\">" ++ " after " ++ while html "</span>" ++ (printOperand 11 exp' indent irMap html comments)
+printPatternScope (PatScopeBetweenAnd _ exp1 exp2) indent irMap html comments = while html "<span class=\"tKeyword\">" ++ " between " ++ while html "</span>" ++ printOperand 11 exp1 indent irMap html comments ++ while html "<span class=\"tKeyword\">" ++ " and " ++ while html "</span>" ++ printOperand 11 exp2 indent irMap html comments
+printPatternScope (PatScopeAfterUntil _ exp1 exp2) indent irMap html comments = while html "<span class=\"tKeyword\">" ++ " after " ++ while html "</span>" ++ printOperand 11 exp1 indent irMap html comments ++ while html "<span class=\"tKeyword\">" ++ " until " ++ while html "</span>" ++ printOperand 11 exp2 indent irMap html comments
+printPatternScope _                           _      _     _    _        = ""
+
 printQuant :: Quant -> Bool -> String
 printQuant quant' html = case quant' of
-  (QuantNo _)       -> (while html "<span class=\"keyword\">") ++ "no" ++ (while html "</span>") ++ " "
-  (QuantNot _)       -> (while html "<span class=\"keyword\">") ++ "not" ++ (while html "</span>") ++ " "
-  (QuantLone _)     -> (while html "<span class=\"keyword\">") ++ "lone" ++ (while html "</span>") ++ " "
-  (QuantOne _)      -> (while html "<span class=\"keyword\">") ++ "one" ++ (while html "</span>") ++ " "
-  (QuantSome _)     -> (while html "<span class=\"keyword\">") ++ "some" ++ (while html "</span>") ++ " "
+  (QuantNo _)   -> while html "<span class=\"keyword\">" ++ "no" ++ while html "</span>" ++ " "
+  (QuantNot _)  -> while html "<span class=\"keyword\">" ++ "not" ++ while html "</span>" ++ " "
+  (QuantLone _) -> while html "<span class=\"keyword\">" ++ "lone" ++ while html "</span>" ++ " "
+  (QuantOne _)  -> while html "<span class=\"keyword\">" ++ "one" ++ while html "</span>" ++ " "
+  (QuantSome _) -> while html "<span class=\"keyword\">" ++ "some" ++ while html "</span>" ++ " "
 
 printEnumId :: EnumId -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
 printEnumId (EnumIdIdent _ posident) _ irMap html _ = printPosIdent posident mUid' html
@@ -384,35 +559,28 @@
     mUid' = getUid posident irMap
 
 printIndent :: Int -> Bool -> String
-printIndent 0 html = (while html "<div>") ++ "\n"
-printIndent _ html = (while html "<div class=\"indent\">") ++ "\n"
+printIndent 0 html = while html "<div>" ++ "\n"
+printIndent _ html = while html "<div class=\"indent\">" ++ "\n"
 
 printIndentId :: Int -> Bool -> String
-printIndentId 0 html = while html ("<div>") ++ "\n"
-printIndentId _ html = while html ("<div class=\"indent\">") ++ "\n"
+printIndentId 0 html = while html "<div>" ++ "\n"
+printIndentId _ html = while html "<div class=\"indent\">" ++ "\n"
 
 printIndentEnd :: Bool -> String
-printIndentEnd html = (while html "</div>") ++ "\n"
-
-dropUid :: String -> String
-dropUid uid' = let id' = rest $ dropWhile (/= '_') uid'
-              in if id' == ""
-                then uid'
-                else id'
+printIndentEnd html = while html "</div>" ++ "\n"
 
---so it fails more gracefully on empty lists
-{-first :: String -> String
-first [] = []
-first (x:_) = x-}
-rest :: String -> String
-rest [] = []
-rest (_:xs) = xs
+-- | The name of a clafer or local in an expression of the IR: a clafer's name (its _ident),
+--   found in the trace of the IR, whose UID need not contain it; a local's name is itself.
+nameIn :: Map.Map Span [Ir] -> String -> String
+nameIn irMap uid' = case [ _ident c | IRClafer c <- concat (Map.elems irMap), _uid c == uid' ] of
+  (name : _) -> name
+  []         -> uid'
 
 getUid :: PosIdent -> Map.Map Span [Ir] -> Maybe String
 getUid posIdent@(PosIdent (_, id')) irMap =
   case Map.lookup (getSpan posIdent) irMap of
     Nothing -> Nothing
-    Just wrappedResultList -> listToMaybe $ catMaybes $ map (findUid id') $ map unwrap wrappedResultList
+    Just wrappedResultList -> listToMaybe $ mapMaybe (findUid id' . unwrap) wrappedResultList
   where
     unwrap (IRPExp pexp')       = getIdentPExp pexp'
     unwrap (IRClafer iClafer') = [ _uid iClafer' ]
@@ -422,20 +590,21 @@
     getIdentIExp (IClaferId _ id'' _ _) = [id'']
     getIdentIExp (IDeclPExp _ _ pexp) = getIdentPExp pexp
     getIdentIExp _ = []
-    findUid name (x:xs) = if name == dropUid x then Just x else findUid name xs
-    findUid _    []     = Nothing
+    -- the UID of the clafer named so; one UID is the one
+    findUid _    [x]    = Just x
+    findUid name xs     = find ((== name) . nameIn irMap) xs
 
 getDivId :: Span -> Map.Map Span [Ir] -> String
-getDivId s irMap = if Map.lookup s irMap == Nothing
+getDivId s irMap = if isNothing $ Map.lookup s irMap
                       then "Uid not Found"
                       else let IRClafer iClaf = head $ fromJust $ Map.lookup s irMap in
                         _uid iClaf
 
 getUseId :: Span -> Map.Map Span [Ir] -> (String, String)
-getUseId s irMap = if Map.lookup s irMap == Nothing
+getUseId s irMap = if isNothing $ Map.lookup s irMap
                       then ("Uid not Found", "Uid not Found")
                       else let IRClafer iClaf = head $ fromJust $ Map.lookup s irMap in
-                        (_uid iClaf, fromMaybe "" $ _sident <$> _exp <$> _super iClaf)
+                        (_uid iClaf, fromMaybe "" $ _sident . _exp <$> _super iClaf)
 
 while :: Bool -> String -> String
 while bool exp' = if bool then exp' else ""
@@ -450,23 +619,43 @@
 trim :: String -> String
 trim = let f = reverse . dropWhile isSpace in f . f
 
+-- | The model with its errors highlighted, for a model whose files are not known (e.g., a wiki
+--   page): positions as @line 3 column 5@.
 highlightErrors :: String -> [ClaferErr] -> String
-highlightErrors model errors = "<pre>\n" ++ unlines (replace "<!-- # FRAGMENT /-->" "</pre>\n<!-- # FRAGMENT /-->\n<pre>" --assumes the fragments have been concatenated
-                            (highlightErrors' (replace "//# FRAGMENT" "<!-- # FRAGMENT /-->" (lines model)) errors)) ++ "</pre>"
+highlightErrors = highlightErrorsIn []
+
+-- | The model with its errors highlighted: each file under its name, and the positions of the
+--   errors as @file.cfr:3:5@.
+highlightErrorsIn :: [ModelFile] -> String -> [ClaferErr] -> String
+highlightErrorsIn files model errors = "<pre>\n" ++ unlines (withHeaders $ replace "<!-- # FRAGMENT /-->" "</pre>\n<!-- # FRAGMENT /-->\n<pre>" --assumes the fragments have been concatenated
+                            (highlightErrors' position (replace "//# FRAGMENT" "<!-- # FRAGMENT /-->" (lines model)) errors)) ++ "</pre>"
   where
     replace _ _ []     = []
     replace x y (z:zs) = (if x == z then y else z):replace x y zs
+    position l c
+      | null files = "line " ++ show l ++ " column " ++ show c
+      | otherwise  = let (path, l') = modelPosition files l in path ++ ":" ++ show l' ++ ":" ++ show c
+    -- the lines of the model, one per line of the text: each file starts with its name
+    withHeaders = go 1 (fileStarts files)
+      where
+      go _ _ [] = []
+      go n ((start, path) : starts) ls | start <= n = printFileHeader path : go n starts ls
+      go n starts (l : ls) = l : go (n + 1) starts ls
 
-highlightErrors' :: [String] -> [ClaferErr] -> [String]
-highlightErrors' model' [] = model'
-highlightErrors' model' ((ClaferErr _):es) = highlightErrors' model' es
-highlightErrors' model' ((ParseErr ErrPos{modelPos = Pos l c, fragId = n} msg'):es) =
+highlightErrors' :: (Integer -> Integer -> String) -> [String] -> [ClaferErr] -> [String]
+highlightErrors' _ model' [] = model'
+highlightErrors' position model' (ClaferErr _:es) = highlightErrors' position model' es
+highlightErrors' position model' (ParseErr ErrPos{modelPos = Pos l c, fragId = n} msg':es) =
   let (ls, lss) = genericSplitAt (l + toInteger n) model'
-      newLine = fst (genericSplitAt (c - 1) $ last ls) ++ "<span class=\"error\" title=\"Parsing failed at line " ++ show l ++ " column " ++ show c ++
-           "...\n" ++ msg' ++ "\">" ++ (if snd (genericSplitAt (c - 1) $ last ls) == "" then "&nbsp;" else snd (genericSplitAt (c - 1) $ last ls)) ++ "</span>"
-  in highlightErrors' (init ls ++ [newLine] ++ lss) es
-highlightErrors' model' ((SemanticErr ErrPos{modelPos = Pos l c, fragId = n} msg'):es) =
+      newLine = fst (genericSplitAt (c - 1) $ last ls) ++ "<span class=\"error\" title=\"Parsing failed at " ++ position l c ++
+           "...\n" ++ escapeHtml msg' ++ "\">" ++ (if snd (genericSplitAt (c - 1) $ last ls) == "" then "&nbsp;" else snd (genericSplitAt (c - 1) $ last ls)) ++ "</span>"
+  in highlightErrors' position (init ls ++ [newLine] ++ lss) es
+highlightErrors' position model' (SemanticErr ErrPos{modelPos = Pos l c, fragId = n} msg':es) =
   let (ls, lss) = genericSplitAt (l + toInteger n) model'
-      newLine = fst (genericSplitAt (c - 1) $ last ls) ++ "<span class=\"error\" title=\"Compiling failed at line " ++ show l ++ " column " ++ show c ++
-           "...\n" ++ msg' ++ "\">" ++ (if snd (genericSplitAt (c - 1) $ last ls) == "" then "&nbsp;" else snd (genericSplitAt (c - 1) $ last ls)) ++ "</span>"
-  in highlightErrors' (init ls ++ [newLine] ++ lss) es
+      newLine = fst (genericSplitAt (c - 1) $ last ls) ++ "<span class=\"error\" title=\"Compiling failed at " ++ position l c ++
+           "...\n" ++ escapeHtml msg' ++ "\">" ++ (if snd (genericSplitAt (c - 1) $ last ls) == "" then "&nbsp;" else snd (genericSplitAt (c - 1) $ last ls)) ++ "</span>"
+  in highlightErrors' position (init ls ++ [newLine] ++ lss) es
+
+-- | The header of a file of the model in the HTML output: its name.
+printFileHeader :: FilePath -> String
+printFileHeader path = "<div class=\"file\">" ++ escapeHtml path ++ "</div>"
diff --git a/src/Language/Clafer/Generator/Stats.hs b/src/Language/Clafer/Generator/Stats.hs
--- a/src/Language/Clafer/Generator/Stats.hs
+++ b/src/Language/Clafer/Generator/Stats.hs
@@ -22,6 +22,7 @@
 -}
 module Language.Clafer.Generator.Stats where
 
+import Control.Monad
 import Control.Monad.State
 import Data.Maybe (isJust)
 
diff --git a/src/Language/Clafer/Import.hs b/src/Language/Clafer/Import.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Clafer/Import.hs
@@ -0,0 +1,404 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-
+ Copyright (C) 2026 Michal Antkiewicz <http://gsd.uwaterloo.ca>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-}
+{- | Models made of several files: a model imports other files with the option
+@--import=FILE@, in its @//# OPTIONS@ directive or on the command line. The imported
+files are compiled with the model as one model, with one namespace, before it and
+each only once; their options are combined with the model's ('combineOptions').
+
+A model and its imports are local files or URLs (@http://@, @https://@). An import is
+relative to the importing file: to its folder, or to its URL. A model read from a URL
+may only import URLs.
+
+An import must be a @.cfr@ file: a URL's path must end with @.cfr@, also after a redirect, and
+a URL served as HTML, JSON or XML is refused. Then a model, which may come from anyone (e.g.,
+in a web tool), cannot read other files or web pages, whose text the errors would show.
+-}
+module Language.Clafer.Import
+  ( ModelFile (..)
+  , Location (..)
+  , readModel
+  , location
+  , importLocation
+  , fileOptions
+  , combineOptions
+  , modelText
+  , modelPosition
+  , fileStarts
+  , isPublicAddress
+  , isModelPath
+  , isModelContentType
+  ) where
+
+import Control.Exception (IOException, bracketOnError, catch, displayException, fromException, try)
+import Control.Monad
+import Control.Monad.Except
+import Control.Monad.State
+import qualified Data.ByteString as B
+import qualified Data.ByteString.Char8 as BC
+import Data.IORef
+import Data.Char (isSpace, toLower)
+import Data.List (dropWhileEnd, find, intercalate, isPrefixOf, isSuffixOf, nub)
+import qualified Data.Text as T
+import qualified Data.Text.Encoding as TE
+import Data.Text.Encoding.Error (lenientDecode)
+import Data.Default (def)
+import qualified Network.Connection as NC
+import Network.HTTP.Client (BodyReader, HttpException (..), HttpExceptionContent (..), Manager, ManagerSettings (..), brRead, getOriginalRequest, getUri, managerSetProxy, newManager, noProxy, parseUrlThrow, responseBody, responseHeaders, responseStatus, responseTimeoutMicro, withResponse)
+import qualified Network.HTTP.Client as HC (path)
+import Network.HTTP.Client.Internal (Connection, makeConnection)
+import Network.HTTP.Client.TLS (newTlsManager, tlsManagerSettings)
+import Network.Socket (AddrInfo (..), Family (AF_INET), HostAddress, SockAddr (..), SocketType (Stream), close, connect, defaultHints, getAddrInfo, hostAddressToTuple, socket)
+import Network.HTTP.Types.Header (hContentType)
+import Network.HTTP.Types.Status (statusCode, statusMessage)
+import Network.URI (URI (..), escapeURIString, isUnescapedInURI, parseAbsoluteURI, parseRelativeReference, relativeTo, unEscapeString, uriToString)
+import System.Console.CmdArgs (cmdArgsValue)
+import System.Console.CmdArgs.Explicit (process)
+import System.Directory (canonicalizePath, doesFileExist)
+import System.FilePath (isAbsolute, normalise, splitDirectories, takeDirectory, takeFileName, (</>))
+import qualified System.IO as IO
+import System.IO.Error (ioeGetErrorString)
+
+import Language.Clafer.ClaferArgs
+import Language.Clafer.SplitJoin (splitArgs)
+
+-- | A file of a model and its text, which ends with a newline.
+data ModelFile = ModelFile
+  { modelFilePath :: FilePath  -- ^ its path or URL, as shown in messages
+  , modelFileText :: String
+  } deriving (Eq, Show)
+
+-- | Where a file of a model is: a local path, or a URL (http or https).
+data Location = Local FilePath | Remote URI
+  deriving (Eq, Show)
+
+-- | The location of a model file name: a URL with @http://@ or @https://@, otherwise a local
+--   path (a @file://@ URL is its path).
+location :: String -> Location
+location name = case parseAbsoluteURI name of
+  Just uri | uriScheme uri `elem` ["http:", "https:"] -> Remote uri
+  _ | "file://" `isPrefixOf` name -> Local $ unEscapeString $ drop 7 name
+    | otherwise                   -> Local name
+
+-- | The location of an import, relative to the importing file: to its folder, or to its URL.
+--   A file read from a URL may only import URLs.
+importLocation :: Location -> String -> Either String Location
+importLocation importer name = case (location name, importer) of
+  (Remote uri, _) -> Right $ Remote uri
+  (Local path, Local importerPath) -> Right $ Local $ normalise $ takeDirectory importerPath </> path
+  (Local path, Remote base)
+    | "file://" `isPrefixOf` name || isAbsolute path -> Left $ "a model read from a URL cannot import the local file " ++ name
+    | otherwise -> case parseRelativeReference (escapeURIString isUnescapedInURI path) of
+        Just reference -> Right $ Remote $ reference `relativeTo` base
+        Nothing        -> Left $ "the import " ++ name ++ " is not a valid relative URL"
+
+-- | How a location is shown in messages.
+showLocation :: Location -> String
+showLocation (Local path) = path
+showLocation (Remote uri) = uriToString id uri ""
+
+-- | Reads the model given by the arguments (the file or URL 'file', or the standard input if it
+--   is empty) and the files it imports, transitively. Returns the arguments combined with the
+--   options of all files (the given arguments take precedence) and the files: imported files
+--   before the files importing them, each once, and the model last. For a model read from a
+--   URL, 'file' becomes the last segment of the URL's path, which names the outputs.
+readModel :: ClaferArgs -> IO (Either String (ClaferArgs, [ModelFile]))
+readModel args' = do
+  manager <- newIORef Nothing  -- created at the first URL
+  roots <- mapM canonicalizePath (import_root args')
+  runExceptT $ do
+    let root = file args'
+        rootLocation = location root
+        -- the name of the model in messages
+        rootName = if null root then "<stdin>" else root
+        -- the location of the model for its imports: where its text is, or --import-base
+        baseLocation = if null (import_base args') then rootLocation else location (import_base args')
+        fetch = readLocation (public_imports args') manager
+    text <- withNewline <$> if null root then liftIO getContents else fetch False "" rootLocation
+    rootOptions <- liftEither $ either (Left . inFile rootName) Right $ fileOptions text
+    rootImports <- liftEither $ either (Left . inFile rootName) Right $ mapM (importLocation baseLocation) (imports rootOptions)
+    rootKey <- if null root then return [] else (:[]) <$> key baseLocation
+    imported <- flip execStateT ([], []) $
+      forM_ (map location (imports args') ++ rootImports) $ visit fetch roots [ (k, rootName) | k <- rootKey ]
+    options <- liftEither $ combineOptions (snd imported) (rootName, rootOptions)
+    let localName = case rootLocation of
+          Local path -> path
+          Remote uri -> case takeFileName (unEscapeString (uriPath uri)) of { "" -> "model.cfr"; name -> name }
+    return ( (withDefaultMode $ mergeArgs args' options){file = localName}
+           , map fst (snd imported) ++ [ModelFile (if null root then rootName else showLocation rootLocation) text] )
+  where
+  -- the stack of the importing files (key and name), to report cycles
+  visit :: (Bool -> String -> Location -> ExceptT String IO String) -> [FilePath] -> [(String, String)] -> Location -> StateT ([String], [(ModelFile, ClaferArgs)]) (ExceptT String IO) ()
+  visit fetch roots stack loc = do
+    let importer = maybe "the command line" snd $ safeHead stack
+        name = showLocation loc
+    -- before anything is known about the file, e.g., whether it exists
+    unless (isModelPath $ locationPath loc) $
+      throwError $ inFile importer $ "the import " ++ name ++ " is not a .cfr file"
+    lift $ insideRoots importer roots loc
+    k <- lift $ either (const $ return name) return =<< liftIO (runExceptT (key loc))
+    when (k `elem` map fst stack) $
+      throwError $ "Import cycle: " ++ intercalate " imports " (reverse (name : map snd (takeWhile ((/= k) . fst) stack) ++ [name]))
+    done <- gets fst
+    unless (k `elem` done) $ do
+      text <- withNewline <$> lift (fetch True importer loc)
+      options <- either (throwError . inFile name) return $ fileOptions text
+      locations <- either (throwError . inFile name) return $ mapM (importLocation loc) (imports options)
+      forM_ locations $ visit fetch roots ((k, name) : stack)
+      modify $ \(done', files) -> (k : done', files ++ [(ModelFile name text, options)])
+  -- identifies a file: its real path, or its URL
+  key :: Location -> ExceptT String IO String
+  key (Local path) = do
+    exists <- liftIO $ doesFileExist path
+    if exists then liftIO (canonicalizePath path) else return path
+  key loc@(Remote _) = return $ showLocation loc
+  safeHead xs = case xs of { x : _ -> Just x; [] -> Nothing }
+  locationPath (Local path) = path
+  locationPath (Remote uri) = unEscapeString $ uriPath uri
+  withDefaultMode a = if null (mode a) then a{mode = [Alloy]} else a
+
+-- | Whether a path names a Clafer model: it ends with @.cfr@.
+isModelPath :: String -> Bool
+isModelPath = (".cfr" `isSuffixOf`)
+
+-- | Whether a URL's Content-Type may be a Clafer model: not HTML, JSON or XML, which web pages
+--   and services are served as, whatever their URLs.
+isModelContentType :: Maybe B.ByteString -> Bool
+isModelContentType Nothing = True
+isModelContentType (Just value) = not $
+  mediaType `elem` ["text/html", "application/xhtml+xml", "application/json", "text/json", "application/xml", "text/xml"]
+  || any (`isSuffixOf` mediaType) ["+json", "+xml"]
+  where mediaType = map toLower $ dropWhileEnd isSpace $ dropWhile isSpace $ takeWhile (/= ';') $ BC.unpack value
+
+-- | With import roots (--import-root), a local file must be inside one of them, after resolving
+--   @..@ and symbolic links.
+insideRoots :: String -> [FilePath] -> Location -> ExceptT String IO ()
+insideRoots importer roots@(_ : _) (Local path) = do
+  real <- liftIO $ canonicalizePath path
+  unless (any (\r -> splitDirectories r `isPrefixOf` splitDirectories real) roots) $
+    throwError $ inFile importer $ "the import " ++ path ++ " is outside the folders from which files can be imported"
+insideRoots _ _ _ = return ()
+
+-- | The largest file that is downloaded.
+maxDownload :: Int
+maxDownload = 16 * 1024 * 1024
+
+-- | Reads a file or downloads a URL, from a public address only if @public@; the importer names
+--   the file importing it, for messages. An import, downloaded after redirects, must still be a
+--   @.cfr@ file and not be served as a web page ('isModelContentType').
+readLocation :: Bool -> IORef (Maybe Manager) -> Bool -> String -> Location -> ExceptT String IO String
+readLocation _ _ _ importer (Local path) = do
+  exists <- liftIO $ doesFileExist path
+  unless exists $ throwError $ inFile importer $ "the file " ++ path ++ " does not exist"
+  liftIO $ IO.withFile path IO.ReadMode $ \h -> do
+    s <- IO.hGetContents h
+    length s `seq` return s
+readLocation public managerRef isImport importer loc@(Remote uri) = do
+  manager <- liftIO $ readIORef managerRef >>= maybe (newManager' >>= \m -> writeIORef managerRef (Just m) >> return m) return
+  result <- liftIO $ try $ do
+    request <- parseUrlThrow $ showLocation loc
+    withResponse request manager $ \response -> do
+      -- the request of the response, after redirects
+      let final = getOriginalRequest response
+          contentType = lookup hContentType $ responseHeaders response
+      if isImport && not (isModelPath $ unEscapeString $ BC.unpack $ HC.path final)
+      then return $ Left $ "redirected to " ++ uriToString id (getUri final) "" ++ ", which is not a .cfr file"
+      else if isImport && not (isModelContentType contentType)
+      then return $ Left $ "it is served as " ++ maybe "" BC.unpack contentType ++ ", not as a Clafer model"
+      else maybe (Left $ "larger than " ++ show (maxDownload `div` (1024 * 1024)) ++ " MB") Right
+             <$> readBody 0 [] (responseBody response)
+  case result of
+    Right (Left problem) -> throwError $ inFile importer $ "cannot read " ++ showLocation loc ++ ": " ++ problem
+    Right (Right body) -> return $ T.unpack $ TE.decodeUtf8With lenientDecode body
+    Left (HttpExceptionRequest _ (StatusCodeException response _)) ->
+      throwError $ inFile importer $ "cannot read " ++ showLocation loc ++ ": HTTP "
+        ++ show (statusCode $ responseStatus response) ++ " " ++ T.unpack (TE.decodeUtf8With lenientDecode $ statusMessage $ responseStatus response)
+    Left (HttpExceptionRequest _ (ConnectionFailure e)) -> throwError $ inFile importer $ "cannot read " ++ showLocation loc ++ ": "
+      ++ maybe (displayException e) ioeGetErrorString (fromException e)
+    Left (HttpExceptionRequest _ content) -> throwError $ inFile importer $ "cannot read " ++ showLocation loc ++ ": " ++ show content
+    Left (InvalidUrlException _ reason) -> throwError $ inFile importer $ "invalid URL " ++ uriToString id uri "" ++ ": " ++ reason
+  where
+  newManager' = if public then newManager publicManagerSettings else newTlsManager
+  -- the body, unless it is larger than maxDownload
+  readBody :: Int -> [B.ByteString] -> BodyReader -> IO (Maybe B.ByteString)
+  readBody size chunks reader = do
+    chunk <- brRead reader
+    let size' = size + B.length chunk
+    if B.null chunk then return $ Just $ B.concat $ reverse chunks
+    else if size' > maxDownload then return Nothing
+    else readBody size' (chunk : chunks) reader
+
+-- | Connections to public addresses only: the address is checked when connecting (also after a
+--   redirect), and the connection is made to that address; no proxy.
+publicManagerSettings :: ManagerSettings
+publicManagerSettings = managerSetProxy noProxy tlsManagerSettings
+  { managerRawConnection = do
+      raw <- managerRawConnection tlsManagerSettings
+      return $ \_ host port -> do
+        address <- publicAddress host
+        raw (Just address) host port
+  , managerTlsConnection = do
+      context <- NC.initConnectionContext
+      return $ \_ host port -> do
+        address <- publicAddress host
+        tlsConnection context address host port
+  , managerResponseTimeout = responseTimeoutMicro 30000000
+  }
+
+-- | A public IPv4 address of the host, or an error.
+publicAddress :: String -> IO HostAddress
+publicAddress host = do
+  infos <- getAddrInfo (Just defaultHints{ addrFamily = AF_INET, addrSocketType = Stream }) (Just host) Nothing
+  case find isPublicAddress [ a | SockAddrInet _ a <- map addrAddress infos ] of
+    Just address -> return address
+    Nothing -> ioError $ userError $ "the host " ++ host ++ " has no public address"
+
+-- | A TLS connection to the address, for the host.
+tlsConnection :: NC.ConnectionContext -> HostAddress -> String -> Int -> IO Connection
+tlsConnection context address host port =
+  bracketOnError (socket AF_INET Stream 0) close $ \sock -> do
+    connect sock (SockAddrInet (fromIntegral port) address)
+    conn <- NC.connectFromSocket context sock NC.ConnectionParams
+      { NC.connectionHostname = host
+      , NC.connectionPort = fromIntegral port
+      , NC.connectionUseSecure = Just def  -- validates the certificate for the host
+      , NC.connectionUseSocks = Nothing
+      }
+    makeConnection (NC.connectionGetChunk conn) (NC.connectionPut conn)
+      (NC.connectionClose conn `catch` \(_ :: IOException) -> return ())
+
+-- | Whether an IPv4 address is public: not unspecified, loopback, private, shared, link-local,
+--   reserved, benchmarking, multicast or broadcast.
+isPublicAddress :: HostAddress -> Bool
+isPublicAddress address = not $ case hostAddressToTuple address of
+  (0, _, _, _)                       -> True
+  (10, _, _, _)                      -> True
+  (100, b, _, _) | b >= 64 && b < 128 -> True
+  (127, _, _, _)                     -> True
+  (169, 254, _, _)                   -> True
+  (172, b, _, _) | b >= 16 && b < 32  -> True
+  (192, 0, 0, _)                     -> True
+  (192, 0, 2, _)                     -> True
+  (192, 168, _, _)                   -> True
+  (198, b, _, _) | b == 18 || b == 19 -> True
+  (198, 51, 100, _)                  -> True
+  (203, 0, 113, _)                   -> True
+  (a, _, _, _)                       -> a >= 224
+
+inFile :: FilePath -> String -> String
+inFile path message = (if null path then "" else path ++ ": ") ++ message
+
+withNewline :: String -> String
+withNewline s = if null s || last s == '\n' then s else s ++ "\n"
+
+-- | The options of a model's @//# OPTIONS@ directive, its first line; the defaults without one.
+fileOptions :: String -> Either String ClaferArgs
+fileOptions model
+  | "//# OPTIONS " `isPrefixOf` model =
+      either (Left . ("//# OPTIONS: " ++)) (Right . withExplicit . cmdArgsValue) $
+        process claferMode $ splitArgs $ filter (/= '\r') $ drop 12 $ takeWhile (/= '\n') model
+  | otherwise = Right claferDefaults
+
+{- | Combines the options of the imported files and of the model:
+
+* the largest @--maxint@, @--decimal-digits@, @--tl@ and @--timeout-analysis@, the smallest @--minint@;
+* all modes (@-m@) and imports;
+* @-k@, @-c@, @--check-afm@ and @-i@ if any file has them, @-f@ only if all files have it;
+* the layout (@-l@, @--nl@) and the scope strategy (@--ss@) must be the same in all files,
+  since the files are parsed together;
+* the options of the compilation rather than of the model (e.g., @-s@, @-o@) are only allowed
+  in the model, not in an imported file;
+* the options that run tools or restrict the imports (@-v@, @--tooldir@, @--import-root@,
+  @--public-imports@, @--import-base@) are only allowed on the command line: a model, which may
+  come from anyone, cannot set them for itself.
+-}
+combineOptions :: [(ModelFile, ClaferArgs)] -> (FilePath, ClaferArgs) -> Either String ClaferArgs
+combineOptions imported (root, rootOptions) = do
+  forM_ ((root, rootOptions) : files) $ \(path, options) ->
+    case [ name' | (name', isChanged) <- commandLineOptions, isChanged options ] of
+      []     -> return ()
+      names' -> Left $ inFile path $ theOptions names' ++ " can only be given on the command line, not in //# OPTIONS"
+  forM_ imported $ \(ModelFile path _, options) ->
+    case [ name' | (name', isChanged) <- runOptions, isChanged options ] of
+      []     -> return ()
+      names' -> Left $ inFile path $ theOptions names'
+                  ++ " can only be given in the compiled model or on the command line, not in an imported file"
+  forM_ sameOptions $ \(name', isDifferent) ->
+    case [ path | (path, options) <- files, isDifferent options rootOptions ] of
+      []    -> return ()
+      paths -> Left $ "The option " ++ name' ++ " must be the same in all files of the model: it differs in "
+                 ++ intercalate ", " paths ++ " from " ++ root
+  return rootOptions
+    { mode                = nub $ concatMap mode all'
+    , imports             = nub $ concatMap imports all'
+    , maxint              = maximumOf $ map maxint all'
+    , minint              = minimumOf $ map minint all'
+    , decimal_digits      = maximumOf $ map decimal_digits all'
+    , trace_len           = maximum $ map trace_len all'
+    , timeout_analysis    = maximum $ map timeout_analysis all'
+    , keep_unused         = any keep_unused all'
+    , check_duplicates    = any check_duplicates all'
+    , afm                 = any afm all'
+    , flatten_inheritance = any flatten_inheritance all'
+    , skip_resolver       = all skip_resolver all'
+    }
+  where
+  files = [ (path, options) | (ModelFile path _, options) <- imported ]
+  all' = rootOptions : map snd files
+  maximumOf xs = case [ x | Just x <- xs ] of { [] -> Nothing; ys -> Just (maximum ys) }
+  minimumOf xs = case [ x | Just x <- xs ] of { [] -> Nothing; ys -> Just (minimum ys) }
+  -- the options of the compilation, which differ from the defaults
+  runOptions =
+    [ ("-o", changed console_output), ("-s", changed no_stats)
+    , ("-a", changed alloy_mapping), ("--self-contained", changed self_contained)
+    , ("--add-graph", changed add_graph), ("--sr", changed show_references), ("--add-comments", changed add_comments)
+    , ("--meta-data", changed meta_data), ("--ecore2clafer", changed ecore2clafer), ("a model file", changed file) ]
+  theOptions [name'] = "the option " ++ name'
+  theOptions names' = "the options " ++ intercalate ", " names'
+  -- the options that run tools or restrict the imports, which a model cannot set for itself
+  commandLineOptions =
+    [ ("-v", changed validate), ("--tooldir", changed tooldir), ("--import-root", changed import_root)
+    , ("--public-imports", changed public_imports), ("--import-base", changed import_base) ]
+  changed :: Eq a => (ClaferArgs -> a) -> ClaferArgs -> Bool
+  changed f options = f options /= f claferDefaults
+  sameOptions =
+    [ ("-l", differs no_layout), ("--nl", differs new_layout), ("--ss", differs scope_strategy) ]
+  differs :: Eq a => (ClaferArgs -> a) -> ClaferArgs -> ClaferArgs -> Bool
+  differs f a b = f a /= f b
+
+-- | The text of the complete model: the files in order.
+modelText :: [ModelFile] -> String
+modelText = concatMap modelFileText
+
+-- | The files and the lines of the complete model where they start (lines from 1).
+fileStarts :: [ModelFile] -> [(Integer, FilePath)]
+fileStarts files = zip (scanl (+) 1 [ fromIntegral $ length $ filter (== '\n') text | ModelFile _ text <- files ]) (map modelFilePath files)
+
+-- | The file and the line in it of a line of the complete model (lines from 1).
+modelPosition :: [ModelFile] -> Integer -> (FilePath, Integer)
+modelPosition files line = go 1 files
+  where
+  go _ [] = ("", line)
+  go start (ModelFile path text : rest)
+    | null rest || line < start + size = (path, line - start + 1)
+    | otherwise                        = go (start + size) rest
+    where size = fromIntegral $ length $ filter (== '\n') text
diff --git a/src/Language/Clafer/Intermediate/Desugarer.hs b/src/Language/Clafer/Intermediate/Desugarer.hs
--- a/src/Language/Clafer/Intermediate/Desugarer.hs
+++ b/src/Language/Clafer/Intermediate/Desugarer.hs
@@ -25,23 +25,35 @@
 -}
 module Language.Clafer.Intermediate.Desugarer where
 
+import Data.Data (Data, cast, gmapQ, gmapT)
+import Data.List (nub)
+import Data.Maybe (fromMaybe, mapMaybe)
+import Prelude hiding ((||))
 import Language.Clafer.Common
-import Data.Maybe (fromMaybe)
-import Language.Clafer.Front.AbsClafer
-import Language.Clafer.Intermediate.Intclafer
+import Language.Clafer.Front.AbsClafer as AbsClafer
+import Language.Clafer.Intermediate.Intclafer as IntClafer
 
--- | Transform the AST into the intermediate representation (IR)
+-- | Transform the AST into the intermediate representation (IR). In a dynamic model, the
+--   enumerations are final, so that their literals do not change over time, and an initializer
+--   @:=@ gives the initial value of a reference (see 'desugarInit').
 desugarModule :: Maybe String -> Module -> IModule
-desugarModule mURL (Module _ declarations) = IModule
-  (fromMaybe "" mURL)
-  (declarations >>= desugarEnums >>= desugarDeclaration)
+desugarModule mURL (Module _ declarations) = if isDynamicModule staticModule
+  then desugarWith True
+  else staticModule
+  where
+    -- neither the non-final enumerations nor the initializers make a model dynamic
+    staticModule = desugarWith False
+    desugarWith dynamic' = IModule
+      (fromMaybe "" mURL)
+      (declarations >>= desugarEnums dynamic' >>= desugarDeclaration dynamic')
 
 sugarModule :: IModule -> Module
 sugarModule x = Module noSpan $ map sugarDeclaration $ _mDecls x -- (fragments x >>= mDecls)
 
--- | desugars enumeration to abstract and global singleton features
-desugarEnums :: Declaration -> [Declaration]
-desugarEnums (EnumDecl (Span p1 p2) id' enumids) = absEnum : map mkEnum enumids
+-- | desugars enumeration to abstract and global singleton features; the abstract clafer is
+--   final if requested, and its literals inherit the finality
+desugarEnums :: Bool -> Declaration -> [Declaration]
+desugarEnums finalEnum (EnumDecl (Span p1 p2) id' enumids) = absEnum : map mkEnum enumids
     where
     p2' = case enumids of
       -- the abstract enum clafer should end before the first literal begins
@@ -54,17 +66,18 @@
       in
         ElementDecl s1 $
           Subclafer s1 $
-            Clafer s1 (Abstract s1) (GCardEmpty s1) id' (SuperEmpty s1) (ReferenceEmpty s1) (CardEmpty s1) (InitEmpty s1) (ElementsList s1 [])
+            Clafer s1 (Abstract s1) [ Final s1 | finalEnum ] (GCardEmpty s1) id' (SuperEmpty s1) (ReferenceEmpty s1) (CardEmpty s1) (InitEmpty s1) (TransitionEmpty s1) (ElementsList s1 [])
     mkEnum (EnumIdIdent s2 eId) = -- each concrete clafer must fit within the original span of the literal
       ElementDecl s2 $
         Subclafer s2 $
-          Clafer s2 (AbstractEmpty s2) (GCardEmpty s2) eId ((SuperSome s2) (ClaferId s2 $ Path s2 [ModIdIdent s2 id'])) (ReferenceEmpty s2) (oneToOne (0, 0)) (InitEmpty s2) (ElementsList s2 [])
-desugarEnums x = [x]
+          Clafer s2 (AbstractEmpty s2) [] (GCardEmpty s2) eId ((SuperSome s2) (ClaferId s2 $ Path s2 [ModIdIdent s2 id'])) (ReferenceEmpty s2) (oneToOne (0, 0)) (InitEmpty s2) (TransitionEmpty s2) (ElementsList s2 [])
+desugarEnums _ x = [x]
 
 
-desugarDeclaration :: Declaration -> [IElement]
-desugarDeclaration (ElementDecl _ element) = desugarElement element
-desugarDeclaration _ = error "Desugarer.desugarDeclaration: enum declarations should have already been converted to clafers. BUG."
+-- | The first argument tells whether the model is dynamic.
+desugarDeclaration :: Bool -> Declaration -> [IElement]
+desugarDeclaration dynamic' (ElementDecl _ element) = desugarElement dynamic' element
+desugarDeclaration _ _ = error "Desugarer.desugarDeclaration: enum declarations should have already been converted to clafers. BUG."
 
 
 sugarDeclaration :: IElement -> Declaration
@@ -76,52 +89,153 @@
 sugarDeclaration  (IEGoal isMaximize' goal) = ElementDecl (_inPos goal) $ Subgoal (_inPos goal) $ sugarGoal goal isMaximize'
 
 
-desugarClafer :: Clafer -> [IElement]
-desugarClafer claf@(Clafer s abstract gcrd' id' super' reference' crd' init' elements') =
+desugarClafer :: Bool -> Clafer -> [IElement]
+-- A reference to a constant, e.g., `-> 1`, is a reference to its type with
+-- the constant as the value: `-> integer = 1`.
+desugarClafer dynamic' (Clafer s abstract' tmods gcrd' id' super' reference' crd' (InitEmpty si) trans' elements')
+  | Just (typeReference, constant') <- referenceToConstant reference' =
+    desugarClafer dynamic' (Clafer s abstract' tmods gcrd' id' super' typeReference crd' (InitSome si (InitConstant si) constant') trans' elements')
+desugarClafer dynamic' claf@(Clafer s abstract' tmods gcrd' id' super' reference' crd' init' trans' elements') =
   case (super', reference') of
     (SuperSome ss setExp, ReferenceEmpty _) -> if isPrimitive $ getPExpClaferIdent setExp
-      then desugarClafer (Clafer s abstract gcrd' id' (SuperEmpty s) (ReferenceSet ss setExp) crd' init' elements')
-      else desugarClafer' claf
+      then desugarClafer' dynamic' (Clafer s abstract' tmods gcrd' id' (SuperEmpty s) (ReferenceSet ss setExp) crd' init' trans' elements')
+      else desugarClafer' dynamic' claf
     (SuperSome _ setExp, ReferenceSet _ _) -> if isPrimitive $ getPExpClaferIdent setExp
       then error "Desugarer: cannot rewrite : with primitive type into -> because a reference is also present. Using : with primitive types is discouraged."
-      else desugarClafer' claf
+      else desugarClafer' dynamic' claf
     (SuperSome _ setExp, ReferenceBag _ _) -> if isPrimitive $ getPExpClaferIdent setExp
       then error "Desugarer: cannot rewrite : with primitive type into -> because a reference is also present. Using : with primitive types is discouraged."
-      else desugarClafer' claf
-    _ -> desugarClafer' claf
-    where
-      desugarClafer' (Clafer s'' abstract'' gcrd'' id'' super'' reference'' crd'' init'' elements'') =
-        (IEClafer $ IClafer s'' (desugarAbstract abstract'') (desugarGCard gcrd'') (transIdent id'')
-            "" "" (desugarSuper super'') (desugarReference reference'') (desugarCard crd'') (0, -1)
-            (desugarElements elements'')) : (desugarInit id'' init'')
+      else desugarClafer' dynamic' claf
+    _ -> desugarClafer' dynamic' claf
 
+-- | For a reference to a constant, the reference to the constant's type, and the constant.
+referenceToConstant :: Reference -> Maybe (Reference, Exp)
+referenceToConstant (ReferenceSet s e) = (\t -> (ReferenceSet s t, e)) <$> constantType e
+referenceToConstant (ReferenceBag s e) = (\t -> (ReferenceBag s t, e)) <$> constantType e
+referenceToConstant _                  = Nothing
+
+-- | The type of a constant, as a reference target.
+constantType :: Exp -> Maybe Exp
+constantType e = typeExp <$> case e of
+    EInt _ _               -> Just integerType
+    EDouble _ _            -> Just doubleType
+    EReal _ _              -> Just decimalType
+    EStr _ _               -> Just stringType
+    EMinExp _ (EInt _ _)   -> Just integerType
+    EMinExp _ (EDouble _ _) -> Just doubleType
+    EMinExp _ (EReal _ _)  -> Just decimalType
+    _                      -> Nothing
+  where
+    s = getSpan e
+    typeExp t = ClaferId s (Path s [ModIdIdent s (mkIdent t)])
+
+desugarClafer' :: Bool -> Clafer -> [IElement]
+desugarClafer' dynamic' claf'@(Clafer s' abstract' tmods' gcrd' id' super' reference' crd' init' _ elements')
+  =  [(IEClafer $ IClafer s' iClaferModifiers (desugarGCard gcrd') (transIdent id')
+                          "" "" (desugarSuper super') (desugarReference tmods' reference')
+                          crd'' (0, -1)
+                          elements'')]
+  ++ parentInit
+  where
+    iClaferModifiers = desugarModifiers abstract' tmods' reference'
+    crd'' = desugarCard crd'
+    (ownInit, parentInit) = desugarInit dynamic' crd'' id' init'
+    -- the transition of a clafer is a constraint of the clafer, whose obligations last as long
+    -- as its parent, e.g., `on --> off` takes the traffic light from on to off
+    elements'' = desugarElements dynamic' elements' ++ desugarClaferTrans claf' ++ ownInit
+
+desugarModifiers :: Abstract -> [TempModifier] -> Reference -> IClaferModifiers
+desugarModifiers    abstract'    tmods           reference' =
+  IClaferModifiers (desugarAbstract abstract') (desugarInitiality tmods) (desugarFinality tmods) inherited
+  where
+  -- finalref or finaltarget of a clafer that inherits its reference, e.g., `finalref motor : engine`
+  inherited = case reference' of
+    ReferenceEmpty _ -> desugarRefModifiers [ m | m <- tmods, isRefMod m ]
+    _ -> []
+  isRefMod (AbsClafer.FinalRef _) = True
+  isRefMod (AbsClafer.FinalTarget _) = True
+  isRefMod _ = False
+
+sugarModifier :: IClaferModifiers -> [TempModifier]
+sugarModifier modifiers' =
+  (if _initial modifiers' then [Initial noSpan] else [])
+  ++
+  (if _final modifiers' then [Final noSpan] else [])
+  ++
+  concatMap sugarRefModifier (_finalReferences modifiers')
+  where
+  sugarRefModifier m = case m of
+     IntClafer.FinalRef -> [AbsClafer.FinalRef noSpan]
+     IntClafer.FinalTarget -> [AbsClafer.FinalTarget noSpan]
+     _ -> []
+
+
 getPExpClaferIdent :: Exp -> String
 getPExpClaferIdent (ClaferId _ (Path _ [ (ModIdIdent _ pident') ] )) = transIdent pident'
 getPExpClaferIdent (EJoin _ _ e2) = getPExpClaferIdent e2
 getPExpClaferIdent _ = error "Desugarer:getPExpClaferIdent not given a ClaferId PExp"
 
 sugarClafer :: IClafer -> Clafer
-sugarClafer (IClafer s abstract gcard' _ uid' _ super' reference' crd' _ elements') =
-    Clafer s (sugarAbstract abstract) (sugarGCard gcard') (mkIdent uid')
-      (sugarSuper super') (sugarReference reference') (sugarCard crd') (InitEmpty s) (sugarElements elements')
-
+sugarClafer (IClafer s modifiers' gcard' _ uid' _ super' reference' crd' _ elements') =
+    Clafer s (sugarAbstract $ _abstract modifiers') (sugarModifier modifiers') (sugarGCard gcard') (mkIdent uid')
+      (sugarSuper super') (sugarReference reference') (sugarCard crd') (InitEmpty s) (TransitionEmpty s) (sugarElements elements')
 
 desugarSuper :: Super -> Maybe PExp
 desugarSuper (SuperEmpty _) = Nothing
 desugarSuper (SuperSome _ (ClaferId _ (Path _ [ (ModIdIdent _ (PosIdent (_, "clafer"))) ] ))) = Nothing
 desugarSuper (SuperSome _ setexp) = Just $ desugarExp setexp
 
-desugarReference :: Reference -> Maybe IReference
-desugarReference (ReferenceEmpty _) = Nothing
-desugarReference (ReferenceSet _ setexp) = Just $ IReference True $ desugarExp setexp
-desugarReference (ReferenceBag _ setexp) = Just $ IReference False $ desugarExp setexp
+desugarReference :: [TempModifier] -> Reference -> Maybe IReference
+desugarReference _ (ReferenceEmpty _) = Nothing
+desugarReference mods (ReferenceSet _ setexp) = Just $ IReference True (desugarRefModifiers mods) $ desugarExp setexp
+desugarReference mods (ReferenceBag _ setexp) = Just $ IReference False (desugarRefModifiers mods) $ desugarExp setexp
 
-desugarInit :: PosIdent -> Init -> [IElement]
-desugarInit _ (InitEmpty _) = []
-desugarInit id' (InitSome s inithow exp') = [ IEConstraint (desugarInitHow inithow) (pExpDefPid s implIExp) ]
+-- | The modifiers of the reference, e.g., `final` in `initial final x -> T`, and both in
+--   `finalref finaltarget x -> T`, each once
+desugarRefModifiers :: [TempModifier] -> [IReferenceModifier]
+desugarRefModifiers mods = nub $ mapMaybe refModifier mods
   where
+  refModifier modi = case modi of
+    Final _ -> Just FinalRefTarget
+    AbsClafer.FinalRef _ -> Just IntClafer.FinalRef
+    AbsClafer.FinalTarget _ -> Just IntClafer.FinalTarget
+    _ -> Nothing
+
+-- | The constraints of the initializer of the clafer @x@: those in the context of @x@, and those
+--   in the context of its parent. All are hard constraints.
+--
+--   * @x -> T = e@ is @[ some x => x.dref = e ]@ in the context of the parent; in a dynamic
+--     model, it holds in every state.
+--   * @x -> T := e@ is the initial value of the reference. In a static model, which has a single
+--     state, it is the same as @=@. In a dynamic model, every lifetime of @x@ starts with the
+--     value: @[ initially this.dref = e ]@ in the context of @x@. The value @e@ is written in the
+--     context of the parent, so the name resolver resolves it there ('iInitValue'): @this@
+--     stays the parent, and a sibling @y@ stays the sibling even if @x@ has a child @y@. So
+--     does a @final@ or @finalref@ reference: it keeps the value that @e@ has when its lifetime
+--     starts, also when @e@ changes later, which @=@ would contradict.
+--   * A set initializer, @xs -> T * := e@, whose cardinality allows more than one instance,
+--     constrains the set of the instances under the parent, so it stays in the context of the
+--     parent: @[ initially (some xs => xs.dref = e) ]@. The instances created later are not
+--     initialized.
+desugarInit :: Bool -> Maybe Interval -> PosIdent -> Init -> ([IElement], [IElement])
+desugarInit _ _ _ (InitEmpty _) = ([], [])
+desugarInit dynamic' crd id' (InitSome s inithow exp') = case inithow of
+    InitDefault _ | dynamic' -> if isSet
+      then ([], [ IEConstraint True $ pExpDefPid s $ IFunExp iInitially [ pExpDefPid s implIExp ] ])
+      else ([ IEConstraint True $ pExpDefPid s $ IFunExp iInitially [ pExpDefPid s ownIExp ] ], [])
+    _ -> ([], [ IEConstraint True (pExpDefPid s implIExp) ])
+  where
+    -- this.dref = initvalue(<exp'>)
+    ownIExp :: IExp
+    ownIExp = IFunExp iEq
+      [ pExpDefPid s $ IFunExp iJoin [ mkPLClaferId s thisIdent False NoBind, mkPLClaferId s drefIdent False NoBind ]
+      , pExpDefPid s $ IFunExp iInitValue [ desugarExp exp' ] ]
+    -- more than one instance of x under a parent instance
+    isSet = case crd of
+      Just (_, ex) -> ex `notElem` [0, 1]  -- -1 is *, unbounded
+      Nothing -> False
     cId :: PExp
-    cId = mkPLClaferId (getSpan id') (snd $ getIdent id') False Nothing
+    cId = mkPLClaferId (getSpan id') (snd $ getIdent id') False NoBind
     -- <id> = <exp'>
     assignIExp :: IExp
     assignIExp = (IFunExp "=" [cId, desugarExp exp'])
@@ -130,15 +244,72 @@
     implIExp = (IFunExp "=>" [ pExpDefPid s $ IDeclPExp ISome [] cId, pExpDefPid s assignIExp ])
     getIdent (PosIdent y) = y
 
-desugarInitHow :: InitHow -> Bool
-desugarInitHow (InitConstant _) = True
-desugarInitHow (InitDefault _ )= False
 
+desugarClaferTrans :: Clafer -> [IElement]
+desugarClaferTrans (Clafer _ _ _ _ name _ _ _ _ trans _) =
+  case trans of
+      TransitionEmpty _ -> []
+      -- the constraint spans the clafer's name and its transition, e.g., green --> yellow; its
+      -- source is the instance of the clafer
+      Transition s arrow e -> let s' = getSpan name >- s in [IEConstraint True (desugarTrans s' (mkClaferIdExp s' thisIdent) arrow e)]
 
+desugarTrans :: Span -> Exp -> TransArrow -> Exp -> PExp
+desugarTrans s e1 arrow e2 = desugarExp $ desugarTrans' s e1 arrow e2
+
+-- | The transitions as in Juodisius et al., Clafer: Lightweight Modeling of Structure,
+--   Behaviour, and Variability (2019), section 6.1: if the precondition holds in a state,
+--   the postcondition holds in the next state (-->), or the precondition and the context
+--   instance last until the postcondition holds (-->>); a guard strengthens the precondition.
+--
+--   Change: a chain of transitions is a sequence, e.g., a scenario
+--   @[ initially (green --> yellow --> red) ]@; only its first precondition is a condition,
+--   so @a --> b --> c@ is @a => X (b && X c)@, not @a => X (b => X c)@.
+desugarTrans' :: Span -> Exp -> TransArrow -> Exp -> Exp
+desugarTrans' s e1 arrow e2 = EImplies s (precondition s e1 arrow) (step s e1 arrow $ desugarSequence e2)
+
+-- | The rest of a chain of transitions: the states follow each other.
+desugarSequence :: Exp -> Exp
+desugarSequence (TransitionExp s e1 arrow e2) = EAnd s (precondition s e1 arrow) (step s e1 arrow $ desugarSequence e2)
+desugarSequence e = e
+
+precondition :: Span -> Exp -> TransArrow -> Exp
+precondition s e1 arrow = case arrow of
+      GuardedSyncTransArrow _ (TransGuard _ guardExp) -> EAnd s e1 guardExp
+      GuardedNextTransArrow _ (TransGuard _ guardExp) -> EAnd s e1 guardExp
+      _ -> e1
+
+-- | The step from the source @e1@ to the target @e2@.
+step :: Span -> Exp -> TransArrow -> Exp -> Exp
+step s e1 arrow e2 = case arrow of
+      SyncTransArrow _ -> multiStep
+      GuardedSyncTransArrow _ _ -> multiStep
+      NextTransArrow _ -> LtlX s e2
+      GuardedNextTransArrow _ _ -> LtlX s e2
+  where
+    this' = mkClaferIdExp s thisIdent
+    -- the source of a clafer's transition is this
+    multiStep = LtlU s (if isThis e1 then this' else EAnd s this' e1) e2
+    isThis (ClaferId _ (Path _ [ModIdIdent _ i])) = transIdent i == thisIdent
+    isThis _ = False
+
+
+desugarFinality :: [TempModifier] -> Bool
+desugarFinality mods = any isFinalMod mods
+  where
+    isFinalMod (Final _) = True
+    isFinalMod _ = False
+
+desugarInitiality :: [TempModifier] -> Bool
+desugarInitiality mods = any isInitialMod mods
+  where
+    isInitialMod (Initial _) = True
+    isInitialMod _ = False
+
+
 desugarName :: Name -> IExp
 desugarName (Path _ path) =
       IClaferId (concatMap ((++ modSep).desugarModId) (init path))
-                (desugarModId $ last path) True Nothing
+                (desugarModId $ last path) True NoBind
 
 desugarModId :: ModId -> Result
 desugarModId (ModIdIdent _ id') = transIdent id'
@@ -152,13 +323,8 @@
 
 sugarReference :: Maybe IReference -> Reference
 sugarReference Nothing = ReferenceEmpty noSpan
-sugarReference (Just (IReference True  pexp')) = ReferenceSet noSpan (sugarExp pexp')
-sugarReference (Just (IReference False pexp')) = ReferenceBag noSpan (sugarExp pexp')
-
-sugarInitHow :: Bool -> InitHow
-sugarInitHow True  = InitConstant noSpan
-sugarInitHow False = InitDefault noSpan
-
+sugarReference (Just (IReference True  _ pexp')) = ReferenceSet noSpan (sugarExp pexp')
+sugarReference (Just (IReference False _ pexp')) = ReferenceBag noSpan (sugarExp pexp')
 
 desugarConstraint :: Constraint -> PExp
 desugarConstraint (Constraint _ exps') = desugarPath $ desugarExp $
@@ -200,21 +366,21 @@
 sugarAbstract True = Abstract noSpan
 
 
-desugarElements :: Elements -> [IElement]
-desugarElements (ElementsEmpty _) = []
-desugarElements (ElementsList _ es)  = es >>= desugarElement
+desugarElements :: Bool -> Elements -> [IElement]
+desugarElements _ (ElementsEmpty _) = []
+desugarElements dynamic' (ElementsList _ es)  = es >>= desugarElement dynamic'
 
 
 sugarElements :: [IElement] -> Elements
 sugarElements x = ElementsList noSpan $ map sugarElement x
 
 
-desugarElement :: Element -> [IElement]
-desugarElement x = case x of
-  Subclafer _ claf  -> (desugarClafer claf)
-  ClaferUse s name crd es  -> desugarClafer $ Clafer s
-      (AbstractEmpty s) (GCardEmpty s) (mkIdent $ _sident $ desugarName name)
-      (SuperSome s (ClaferId s name)) (ReferenceEmpty s) crd (InitEmpty s) es
+desugarElement :: Bool -> Element -> [IElement]
+desugarElement dynamic' x = case x of
+  Subclafer _ claf  -> (desugarClafer dynamic' claf)
+  ClaferUse s name crd es  -> desugarClafer dynamic' $ Clafer s
+      (AbstractEmpty s) [] (GCardEmpty s) (mkIdent $ _sident $ desugarName name)
+      (SuperSome s (ClaferId s name)) (ReferenceEmpty s) crd (InitEmpty s) (TransitionEmpty s) es
   Subconstraint _ constraint  ->
       [IEConstraint True $ desugarConstraint constraint]
   SubAssertion _ assertion ->
@@ -237,14 +403,7 @@
   GCardMux _ -> Just $ IGCard True (0, 1)
   GCardOpt _ -> Just $ IGCard True (0, -1)
   GCardInterval _ ncard ->
-      Just $ IGCard (isOptionalDef ncard) $ desugarNCard ncard
-
-isOptionalDef :: NCard -> Bool
-isOptionalDef (NCard _ m n) = ((0::Integer) == mkInteger m) && (not $ isExIntegerAst n)
-
-isExIntegerAst :: ExInteger -> Bool
-isExIntegerAst (ExIntegerAst _) = True
-isExIntegerAst _ = False
+      Just $ IGCard False $ desugarNCard ncard
 
 sugarGCard :: Maybe IGCard -> GCard
 sugarGCard x = case x of
@@ -275,13 +434,87 @@
       CardInterval noSpan $ NCard noSpan (PosInteger ((0, 0), show i)) (sugarExInteger ex)
 
 sugarExInteger :: Integer -> ExInteger
-sugarExInteger n = if n == -1 then ExIntegerAst noSpan else (ExIntegerNum noSpan $ PosInteger ((0, 0), show n))
+sugarExInteger n = if n == -1 then ExIntegerAst noSpan else ExIntegerNum noSpan $ PosInteger ((0, 0), show n)
 
 desugarExp :: Exp -> PExp
 desugarExp x = pExpDefPid (getSpan x) $ desugarExp' x
 
+
+translateTmpPatterns :: Exp -> Exp
+translateTmpPatterns e = case e of
+  TmpPatNever _ p scope -> case scope of
+    PatScopeEmpty _ ->            g $ not' p
+    PatScopeBefore _ r ->         f r ==> (not' p `u` r)
+    PatScopeAfter _ q ->          g(q ==> g (not' p))
+    PatScopeBetweenAnd _ q r ->   g ((q & not' r & f r) ==> (not' p `u` r))
+    PatScopeAfterUntil _ q r ->   g((q & not' r) ==> (not' p `w` r))
+  TmpPatSometime _ p scope -> case scope of
+    PatScopeEmpty _ ->            f p
+    PatScopeBefore _ r ->         not' r `w` (p & not' r)
+    PatScopeAfter _ q ->          g (not' q) || f (q & f p)
+    PatScopeBetweenAnd _ q r ->   g ( (q & not' r) ==> (not' r `w` (p & not' r)) )
+    PatScopeAfterUntil _ q r ->   g ( (q & not' r) ==> (not' r `u` (p & not' r)) )
+  TmpPatLessOrOnce _ p scope -> case scope of
+                                  -- (!P W (P W []!P))
+    PatScopeEmpty _ ->            not' p `w` (p `w` g (not' p))
+                                  -- <> R -> ((!P & !R) U ((R | (P & !R)) U ( R | (!P U R))))
+    PatScopeBefore _ r ->         f r ==> ((not' p & not' r) `u` (r || ((p & not' r) `u` (r || (not' p `u` r)))))
+                                  -- <>Q -> (!Q U (Q & (!P W (P W []!P))))
+    PatScopeAfter _ q ->          f q ==> (not' q `u` (q & (not' p `w` (p `w` g (not' p))) ))
+                                  -- []((Q & <>R) -> ((!P & !R) U (R | ((P & !R) U (R | (!P U R))))))
+    PatScopeBetweenAnd _ q r ->   g((q & f r) ==> ((not' p & not' r) `u` (r || ((p & not' r) `u` (r || (not' p `u` r))))))
+                                  -- [](Q -> ((!P & !R) U (R | ((P & !R) U (R | (!P W R) | []P)))))
+    PatScopeAfterUntil _ q r ->   g(q ==> ((not' p & not' r) `u` (r || ((p & not' r) `u` (r || (not' p `w` r) || g p)))))
+  TmpPatAlways _ p scope -> case scope of
+    PatScopeEmpty _ ->            g p
+    PatScopeBefore _ r ->         f r ==> (p `u` r)
+    PatScopeAfter _ q ->          g (q ==> g p)
+    PatScopeBetweenAnd _ q r ->   g ((q & not' r & f r ) ==> (p `u` r))
+    PatScopeAfterUntil _ q r ->   g((q & not' r) ==> (p `w` r))
+  TmpPatPrecede _ s p scope -> case scope of
+    PatScopeEmpty _ ->            not' p `w` s
+    PatScopeBefore _ r ->         f r ==> (not' p `u` (s || r))
+                                  -- from the first q: Dwyer's []!Q | <>(Q & (!P W S)) may pick a later q
+    PatScopeAfter _ q ->          f q ==> (not' q `u` (q & (not' p `w` s)))
+    PatScopeBetweenAnd _ q r ->   g ((q & not' r & f r) ==> (not' p `u` (s || r)))
+    PatScopeAfterUntil _ q r ->   g ((q & not' r) ==> (not' p `w` (s || r)))
+  TmpPatFollow _ s p scope -> case scope of
+    PatScopeEmpty _ ->            g(p ==> f s)
+    PatScopeBefore _ r ->         f r ==> ((p ==> (not' r `u` (s & not' r))) `u` r)
+    PatScopeAfter _ q ->          g(q ==> g(p ==> f s))
+                                  -- every p up to r: []((Q & !R & <>R) -> ((P -> (!R U (S & !R))) U R))
+    PatScopeBetweenAnd _ q r ->   g((q & not' r & f r) ==> ((p ==> (not' r `u` (s & not' r))) `u` r))
+    PatScopeAfterUntil _ q r ->   g((q & not' r) ==> ((p==> (not' r `u` (s & not' r))) `w` r))
+  {-TmpInitially s exp' -> -}
+    {-let oper1 =  ENeg s $ mkClaferIdExp s "this"-}
+        {-oper2 = LtlX s $ mkClaferIdExp s "this"-}
+    {-in EImplies s (EAnd s oper1 oper2) $ LtlX s exp'-}
+  TmpEventually s exp' -> LtlF s exp'
+  TmpWUntil s exp0 exp1 -> LtlW s exp0 exp1
+  TmpUntil s exp0 exp1 -> LtlU s exp0 exp1
+  TmpGlobally s exp' -> LtlG s exp'
+  TmpNext s exp' -> LtlX s exp'
+  TransitionExp s exp0 arrow exp1 -> desugarTrans' s exp0 arrow exp1
+  _ -> e
+  where
+    infixr 4 `u`
+    infixr 4 `w`
+    infixl 3 &
+    infixl 2 ||
+    infixr 1 ==>
+    w = LtlW span'
+    u = LtlU span'
+    (==>) e1 e2 = EImplies span' e1 e2
+    e1 & e2 = EAnd span' e1 e2
+    e1 || e2 = EOr span' e1 e2
+    f = LtlF span'
+    g = LtlG span'
+    not' = ENeg span'
+    span' = getSpan e
+
+
 desugarExp' :: Exp -> IExp
-desugarExp' x = case x of
+desugarExp' x = let x' =  translateTmpPatterns x in case x' of
   EDeclAllDisj _ decl exp' ->
       IDeclPExp IAll [desugarDecl True decl] (dpe exp')
   EDeclAll _ decl exp' -> IDeclPExp IAll [desugarDecl False decl] (dpe exp')
@@ -296,6 +529,13 @@
   EXor _ exp0 exp'  -> dop iXor [exp0, exp']
   EAnd _ exp0 exp'  -> dop iAnd [exp0, exp']
   ENeg _ exp'  -> dop iNot [exp']
+  LtlU  _ exp0 exp'  -> dop iU  [exp0, exp']
+  LtlW  _ exp0 exp'  -> dop iW  [exp0, exp']
+  LtlF  _ exp'  -> dop iF  [exp']
+  LtlG  _ exp'  -> dop iG  [exp']
+  LtlX  _ exp'  -> dop iX  [exp']
+  TmpInitially _ exp' -> dop iInitially [exp']
+  TmpFinally _ exp' -> dop iFinally [exp']
   EQuantExp _ quant' exp' ->
       IDeclPExp (desugarQuant quant') [] (desugarExp exp')
   ELt  _ exp0 exp'  -> dop iLt  [exp0, exp']
@@ -319,7 +559,8 @@
   EGMin _ exp' -> dop iMinimum [exp']
   EInt _ n  -> IInt $ mkInteger n
   EDouble _ (PosDouble n) -> IDouble $ read $ snd n
-  EReal _ (PosReal n) -> IReal $ read $ snd n
+  -- a plain decimal literal, e.g., 19.99, is a decimal, kept as written
+  EReal _ (PosReal n) -> IDecimal $ snd n
   EStr _ (PosString str)  -> IStr $ snd str
   EUnion _ exp0 exp'        -> dop iUnion        [exp0, exp']
   EUnionCom _ exp0 exp'     -> dop iUnion        [exp0, exp']
@@ -330,10 +571,75 @@
   ERange _ exp0 exp'        -> dop iRange        [exp0, exp']
   EJoin _ exp0 exp'         -> dop iJoin         [exp0, exp']
   ClaferId _ name  -> desugarName name
+  TransitionExp{} -> showPatErr
+  LetExp _ vb e -> desugarExp' $ desugarLet vb e
+  TmpPatNever{} -> showPatErr
+  TmpPatSometime{} -> showPatErr
+  TmpPatLessOrOnce{} -> showPatErr
+  TmpPatAlways{} -> showPatErr
+  TmpPatPrecede{} -> showPatErr
+  TmpPatFollow{} -> showPatErr
+  TmpUntil{} -> showPatErr
+  TmpWUntil{} -> showPatErr
+  TmpEventually{} -> showPatErr
+  TmpNext{} -> showPatErr
+  TmpGlobally{} -> showPatErr
   where
+  showPatErr = error ("[bug] Desugarer: pattern expressions should have been transformed previously. Problem expression:\n" ++ show x)
   dop = desugarOp desugarExp
   dpe = desugarPath.desugarExp
 
+-- | @let v = e in body@ is @body@ with @e@ for the name @v@. A quantifier or a @let@ in @body@
+--   which binds @v@ again hides it there, and one which binds a name used in @e@ is renamed
+--   to a fresh name, e.g., @x_1@, so that @e@ keeps its meaning.
+desugarLet :: VarBinding -> Exp -> Exp
+desugarLet (VarBinding _ (LocIdIdent _ (PosIdent (_, v))) e) = substName v e
+
+-- | Substitutes an expression for the free occurrences of a local name.
+substName :: String -> Exp -> Exp -> Exp
+substName v e = goE
+  where
+  namesOfE = namesIn e
+  go :: Data a => a -> a
+  go x = case cast x of
+    Just ex -> fromMaybe x $ cast $ goE ex
+    Nothing -> gmapT go x
+  goE :: Exp -> Exp
+  goE x = case x of
+    ClaferId _ (Path _ [ModIdIdent _ (PosIdent (_, n))]) | n == v -> e
+    EDeclAllDisj s d b -> let (d', b') = goDecl d b in EDeclAllDisj s d' b'
+    EDeclAll s d b -> let (d', b') = goDecl d b in EDeclAll s d' b'
+    EDeclQuantDisj s q d b -> let (d', b') = goDecl d b in EDeclQuantDisj s q d' b'
+    EDeclQuant s q d b -> let (d', b') = goDecl d b in EDeclQuant s q d' b'
+    LetExp s (VarBinding s' l e') b -> case goBound [l] b of
+      ([l'], b') -> LetExp s (VarBinding s' l' $ goE e') b'
+      _ -> x
+    _ -> gmapT go x
+  goDecl (Decl s ls set) b = let (ls', b') = goBound ls b in (Decl s ls' $ goE set, b')
+  -- the names bound by a quantifier or a let, and its body
+  goBound :: [LocId] -> Exp -> ([LocId], Exp)
+  goBound ls b
+    | v `elem` map locIdName ls  = (ls, b)
+    | v `notElem` namesIn b     = (ls, b)
+    | otherwise                 = (ls', goE $ foldr renameIn b $ zip ls ls')
+    where
+    taken = namesOfE ++ namesIn b ++ map locIdName ls
+    ls' = map rename ls
+    rename l@(LocIdIdent s (PosIdent (p, n)))
+      | n `elem` namesOfE = LocIdIdent s $ PosIdent (p, head [ n' | k <- [1 :: Int ..], let n' = n ++ "_" ++ show k, n' `notElem` taken ])
+      | otherwise         = l
+    renameIn (old, new@(LocIdIdent s _)) b'
+      | old == new = b'
+      | otherwise  = substName (locIdName old) (ClaferId s $ Path s [ModIdIdent s $ locIdPosIdent new]) b'
+  locIdName (LocIdIdent _ (PosIdent (_, n))) = n
+  locIdPosIdent (LocIdIdent _ i) = i
+
+-- | The identifiers in a part of the AST.
+namesIn :: Data a => a -> [String]
+namesIn x = case cast x of
+  Just (PosIdent (_, n)) -> [n]
+  Nothing                -> concat $ gmapQ namesIn x
+
 desugarOp :: (a -> PExp) -> String -> [a] -> IExp
 desugarOp f op' exps' =
     if (op' == iIfThenElse)
@@ -341,7 +647,7 @@
       else IFunExp op' $ map (trans.f) exps'
     where
       mappedList = map f exps'
-      trans = if op' `elem` ([iNot, iIfThenElse] ++ logBinOps)
+      trans = if op' `elem` ([iNot, iIfThenElse] ++ logBinOps ++ ltlUnOps)
           then desugarPath else id
 
 sugarExp :: PExp -> Exp
@@ -363,8 +669,11 @@
   IClaferId modName' id' _ _ -> ClaferId noSpan $ Path noSpan $ (sugarModId modName') : [sugarModId id']
   IInt n -> EInt noSpan $ PosInteger ((0, 0), show n)
   IDouble n -> EDouble noSpan $ PosDouble ((0, 0), show n)
+  IDecimal n -> EReal noSpan $ PosReal ((0, 0), n)
   IReal n -> EReal noSpan $ PosReal ((0, 0), show n)
   IStr str -> EStr noSpan $ PosString ((0, 0), str)
+  -- the value of an initializer, which keeps its context ('iInitValue')
+  IFunExp op' [value] | op' == iInitValue -> sugarExp' $ _exp value
   IFunExp op' exps' ->
     if op' `elem` unOps then (sugarUnOp op') (exps''!!0)
     else if op' `elem` binOps then (sugarOp op') (exps''!!0) (exps''!!1)
@@ -381,6 +690,11 @@
     | op'' == iMinimum       = EGMin noSpan
     | op'' == iSumSet        = ESum noSpan
     | op'' == iProdSet       = EProd noSpan
+    | op'' == iF             = LtlF noSpan
+    | op'' == iG             = LtlG noSpan
+    | op'' == iX             = LtlX noSpan
+    | op'' == iInitially     = TmpInitially noSpan
+    | op'' == iFinally       = TmpFinally noSpan
     | otherwise              = error $ show op'' ++ "is not an op"
   sugarOp op''
     | op'' == iIff           = EIff noSpan
@@ -401,6 +715,8 @@
     | op'' == iMul           = EMul noSpan
     | op'' == iDiv           = EDiv noSpan
     | op'' == iRem           = ERem noSpan
+    | op'' == iU             = LtlU noSpan
+    | op'' == iW             = LtlW noSpan
     | op'' == iUnion         = EUnion noSpan
     | op'' == iDifference    = EDifference noSpan
     | op'' == iIntersection  = EIntersection noSpan
@@ -480,3 +796,6 @@
 sugarQuant IOne = QuantOne noSpan
 sugarQuant ISome = QuantSome noSpan
 sugarQuant IAll = error "sugarQaunt was called on IAll, this is not allowed!" --Should never happen
+
+mkClaferIdExp :: Span -> String -> Exp
+mkClaferIdExp s name = ClaferId s $ Path s [ModIdIdent s $ mkIdent name]
diff --git a/src/Language/Clafer/Intermediate/Intclafer.hs b/src/Language/Clafer/Intermediate/Intclafer.hs
--- a/src/Language/Clafer/Intermediate/Intclafer.hs
+++ b/src/Language/Clafer/Intermediate/Intclafer.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE TemplateHaskell, DeriveDataTypeable #-}
+{-# LANGUAGE TemplateHaskell, DeriveDataTypeable, DeriveGeneric, DeriveAnyClass, OverloadedStrings #-}
 {-
  Copyright (C) 2012-2017 Kacper Bak, Jimmy Liang, Michal Antkiewicz, Luke Michael Brown <http://gsd.uwaterloo.ca>
 
@@ -25,10 +25,10 @@
 
 import Language.Clafer.Front.AbsClafer
 
-import Control.Lens
+import Control.Lens hiding ((.=))
 import Data.Aeson
-import Data.Aeson.TH
 import Data.Data
+import GHC.Generics
 import Data.Monoid
 import Data.Foldable
 import Prelude
@@ -52,12 +52,13 @@
   | IRIQuant IQuant
   | IRIDecl IDecl
   | IRIGCard (Maybe IGCard)
-  deriving (Eq, Show)
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
 data IType
   = TBoolean
   | TString
   | TInteger
+  | TDecimal
   | TDouble
   | TReal
   | TClafer
@@ -70,8 +71,7 @@
   | TUnion
     { _un :: [IType]          -- ^ [IType] is a list of basic types (not union types)
     }
-
-  deriving (Eq,Ord,Show,Data,Typeable)
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
 -- | each file contains exactly one mode. A module is a list of declarations
 data IModule
@@ -79,13 +79,29 @@
     { _mName :: String -- ^ always empty (no syntax for declaring modules)
     , _mDecls :: [IElement] -- ^ List of top-level elements
     }
-  deriving (Eq,Ord,Show,Data,Typeable)
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
+-- | @{"start": pos, "end": pos}@, where the end is exclusive; @null@ for 'noSpan'
+instance ToJSON Span where
+  toJSON s@(Span start' end')
+    | s == noSpan = Null
+    | otherwise   = object [ "start" .= start', "end" .= end' ]
+
+-- | @{"line": l, "column": c}@, both from 1 (a tab advances the column to the next multiple of 8, plus 1); @null@ for 'noPos'
+instance ToJSON Pos where
+  toJSON p@(Pos line' column')
+    | p == noPos = Null
+    | otherwise  = object [ "line" .= line', "column" .= column' ]
+
+-- | The name of an assertion in the Alloy output: its position, since a line can have several assertions.
+assertionName :: PExp -> String
+assertionName PExp{_inPos = Span (Pos line column) _} = "assertAt_" ++ show line ++ "_" ++ show column
+
 -- | Clafer has a list of fields that specify its properties. Some fields, marked as (o) are for generating optimized code
 data IClafer
   = IClafer
     { _cinPos :: Span         -- ^ the position of the syntax in source code
-    , _isAbstract :: Bool     -- ^ whether abstract or not (i.e., concrete)
+    , _modifiers :: IClaferModifiers -- ^ abstract, initial, final
     , _gcard :: Maybe IGCard  -- ^ group cardinality
     , _ident :: CName         -- ^ name declared in the model
     , _uid :: UID             -- ^ a unique identifier
@@ -96,8 +112,30 @@
     , _glCard :: Interval     -- ^ (o) global cardinality
     , _elements :: [IElement] -- ^ nested elements
     }
-  deriving (Eq,Ord,Show,Data,Typeable)
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
+isMutable :: IClafer -> Bool
+isMutable = not . _final . _modifiers
+
+data IClaferModifiers
+  = IClaferModifiers
+  { _abstract :: Bool -- ^ declared as "abstract"
+  , _initial :: Bool  -- ^ declared as "initial"
+  , _final :: Bool    -- ^ declared as "final"
+  , _finalReferences :: [IReferenceModifier]
+    -- ^ declared as "finalref" or "finaltarget" without a reference of its own: the modifiers of
+    --   the reference that the clafer inherits (#109)
+  } deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
+
+_isAbstract :: IClafer -> Bool     -- ^ whether abstract or not (i.e., concrete)
+_isAbstract = _abstract . _modifiers
+
+_isFinal :: IClafer -> Bool     -- ^ whether declared final or not
+_isFinal = _final . _modifiers
+
+_isInitial :: IClafer -> Bool     -- ^ whether declared initial or not
+_isInitial = _initial . _modifiers
+
 -- | Clafer's subelement is either a clafer, a constraint, or a goal (objective)
 --   This is a wrapper type needed to have polymorphic lists of elements
 data IElement
@@ -113,7 +151,7 @@
     { _isMaximize :: Bool     -- ^ whether maximize or minimize
     , _cpexp :: PExp          -- ^ the expression
     }
-  deriving (Eq,Ord,Show,Data,Typeable)
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
 -- | A type of reference.
 --   ->    values unique (set)
@@ -121,22 +159,31 @@
 data IReference
   = IReference
     { _isSet :: Bool -- ^ whether set or bag
+    , _refModifiers :: [IReferenceModifier] -- ^ all of them: `finalref finaltarget` means both
     , _ref :: PExp  -- ^ the only allowed reference expressions are IClafer and set expr. (++, **, --s)
     }
-  deriving (Eq,Ord,Show,Data,Typeable)
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
+data IReferenceModifier
+  = FinalRefTarget
+  | FinalRef
+  | FinalTarget
+  deriving (Eq, Ord, Show, Data, Typeable,Generic,ToJSON)
+
 -- | Group cardinality is specified as an interval. It may also be given by a keyword.
 --   xor    1..1 isKeyword = True
 --   1..1   1..1 isKeyword = False
 data IGCard
   = IGCard
-    { _isKeyword :: Bool    -- ^ whether given by keyword: or, xor, mux
+    { _isKeyword :: Bool    -- ^ whether given by keyword: xor, or, mux, opt
     , _interval :: Interval
-    } deriving (Eq,Ord,Show,Data,Typeable)
+    } deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
 -- | (Min, Max) integer interval. -1 denotes *
 type Interval = (Integer, Integer)
 
+type Mutability = Bool
+
 -- | This is expression container (parent).
 --   It has meta information about an actual expression 'exp'
 data PExp
@@ -146,10 +193,14 @@
     , _inPos :: Span          -- ^ position in the input Clafer file
     , _exp :: IExp            -- ^ the actual expression
     }
-  deriving (Eq,Ord,Show,Data,Typeable)
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
 -- | Embedes reference to a resolved Clafer
-type ClaferBinding = Maybe UID
+{-type ClaferBinding = Maybe UID-}
+data ClaferBinding = GlobalBind UID
+  | LocalBind CName
+  | NoBind
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
 data IExp
     -- | quantified expression with declarations
@@ -171,7 +222,12 @@
   | IInt
     { _iint :: Integer
     }
-    -- | real number
+    -- | decimal number, as written, e.g., "2.50"
+  | IDecimal
+    { _idecimal :: String
+    }
+    -- | real number; there is no literal syntax for reals yet: a plain decimal literal,
+    --   e.g., 19.99, is a decimal
   | IReal
     { _ireal :: Double
     }
@@ -190,7 +246,7 @@
     , _isTop :: Bool             -- ^ identifier refers to a top-level definition
     , _binding :: ClaferBinding  -- ^ the UID of the bound IClafer, if resolved
     }
-  deriving (Eq,Ord,Show,Data,Typeable)
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
 {- |
 For IFunExp standard set of operators includes:
@@ -237,7 +293,7 @@
     , _decls :: [CName]  -- ^ a list of local names
     , _body :: PExp      -- ^ set to which local names refer to
     }
-  deriving (Eq,Ord,Show,Data,Typeable)
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
 -- | quantifier
 data IQuant
@@ -246,7 +302,7 @@
   | IOne   -- ^ exactly one
   | ISome  -- ^ at least one (i.e., exists)
   | IAll   -- ^ for all
-  deriving (Eq,Ord,Show,Data,Typeable)
+  deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
 
 type LineNo = Integer
 type ColNo  = Integer
@@ -296,8 +352,8 @@
 iMap f (IRPExp (PExp Nothing pID p iExp)) =
   f $ IRPExp $ PExp Nothing pID p $ unWrapIExp $ iMap f $ IRIExp iExp
 iMap _ x@(IRIReference Nothing) = x
-iMap f (IRIReference (Just (IReference is ref))) =
- f $ IRIReference $ Just $ IReference is $ (unWrapPExp . iMap f . IRPExp) ref
+iMap f (IRIReference (Just (IReference is mod' ref))) =
+ f $ IRIReference $ Just $ IReference is mod' ((unWrapPExp . iMap f . IRPExp) ref)
 iMap f (IRIDecl (IDecl i d body')) =
   f $ IRIDecl $ IDecl i d $ unWrapPExp $ iMap f $ IRPExp body'
 iMap f i = f i
@@ -320,7 +376,7 @@
 iFoldMap f i@(IRPExp (PExp Nothing _ _ iExp)) =
   f i `mappend` (iFoldMap f $ IRIExp iExp)
 iFoldMap f i@(IRIReference Nothing) = f i
-iFoldMap f i@(IRIReference (Just (IReference _ ref))) =
+iFoldMap f i@(IRIReference (Just (IReference _ _ ref))) =
   f i `mappend` (iFoldMap f . IRPExp) ref
 iFoldMap f i@(IRIDecl (IDecl _ _ body')) =
   f i `mappend` (iFoldMap f $ IRPExp body')
@@ -368,54 +424,20 @@
 instance Plated IExp
 
 makeLenses ''IType
-
 makeLenses ''IModule
-
 makeLenses ''IClafer
-
 makeLenses ''IElement
-
+makeLenses ''IClaferModifiers
+makeLenses ''IReferenceModifier
 makeLenses ''IReference
-
 makeLenses ''IGCard
-
 makeLenses ''PExp
-
 makeLenses ''IExp
-
 makeLenses ''IDecl
 
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail, omitNothingFields=True} ''IType)
-
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail, omitNothingFields=True} ''IModule)
-
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail, omitNothingFields=True} ''IClafer)
-
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail, omitNothingFields=True} ''IElement)
-
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail, omitNothingFields=True} ''IReference)
-
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail, omitNothingFields=True} ''IGCard)
-
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail, omitNothingFields=True} ''PExp)
-
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail, omitNothingFields=True} ''IExp)
-
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail, omitNothingFields=True} ''IDecl)
-
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail, omitNothingFields=True} ''IQuant)
-
-instance ToJSON Span where
-  toJSON _ = Null
-
-instance ToJSON Pos where
-  toJSON _ = Null
-
 -- | Datatype used for JSON output. See Language.Clafer.gatherObjectivesAndAttributes
 data ObjectivesAndAttributes
   = ObjectivesAndAttributes
     { _qualities :: [String]
     , _attributes :: [String]
-    }
-
-$(deriveToJSON defaultOptions{fieldLabelModifier = tail} ''ObjectivesAndAttributes)
+    } deriving (Eq,Ord,Show,Data,Typeable,Generic,ToJSON)
diff --git a/src/Language/Clafer/Intermediate/Resolver.hs b/src/Language/Clafer/Intermediate/Resolver.hs
--- a/src/Language/Clafer/Intermediate/Resolver.hs
+++ b/src/Language/Clafer/Intermediate/Resolver.hs
@@ -24,8 +24,8 @@
 
 import Control.Monad
 import Control.Monad.State
+import Data.List (mapAccumL)
 import qualified Data.Map as Map
-import qualified Data.StringMap as SMap
 
 import Language.Clafer.Common
 import Language.Clafer.ClaferArgs
@@ -33,40 +33,58 @@
 import Language.Clafer.Intermediate.ResolverName
 import Language.Clafer.Intermediate.ResolverType
 import Language.Clafer.Intermediate.ResolverInheritance
+import Language.Clafer.Intermediate.ResolverRoot
+import Language.Clafer.Intermediate.UIDs (assignUIDs)
 
--- | Run the various resolvers
+-- | Run the various resolvers. With -f (skip_resolver), the names are the UIDs, as in an
+-- | explicit model: the clafers are not renamed, but all names are still resolved and checked.
 resolveModule :: ClaferArgs -> IModule -> Resolve (IModule, GEnv)
 resolveModule    args'         imodule =
   do
     r <- resolveNModule $ nameModule (skip_resolver args') imodule
-    resolveNamesModule args' =<< rom' (rem' r)
+    resolveNamesModule =<< resolveOModule (rem' r)
   where
   rem' = if flatten_inheritance args' then resolveEModule else id
-  rom' = if skip_resolver args' then return else resolveOModule
 
 
 -- | Name resolver
+-- | Gives every clafer its UID (see "Language.Clafer.Intermediate.UIDs"), or with -f its name,
+-- | and every expression its id.
 nameModule :: Bool -> IModule -> (IModule, GEnv)
 nameModule skipResolver imodule = (imodule', genv'')
   where
-    (decls', genv') = runState (mapM (nameElement skipResolver "root") $ _mDecls imodule) $ GEnv Map.empty 0 Map.empty [] SMap.empty
+    paths = concatMap (claferPaths []) $ _mDecls imodule
+    uids = if skipResolver then map last paths else assignUIDs paths
+    named = snd $ mapAccumL withUIDs uids $ _mDecls imodule
+    (decls', genv') = runState (mapM (nameElement "root") named) $ GEnv Map.empty 0 Map.empty [] Map.empty
     imodule' = imodule{_mDecls = decls'}
     genv'' = genv'{uidClaferMap = createUidIClaferMap imodule'}
 
+-- | The names of the clafers and their ancestors, from the top level, in pre-order.
+claferPaths :: [String] -> IElement -> [[String]]
+claferPaths path (IEClafer claf) = path' : concatMap (claferPaths path') (_elements claf)
+  where path' = path ++ [_ident claf]
+claferPaths _ _ = []
 
-nameElement :: MonadState GEnv m => Bool -> UID -> IElement -> m IElement
-nameElement skipResolver puid x = case x of
-  IEClafer claf -> IEClafer <$> nameClafer skipResolver puid claf
+-- | Sets the UIDs of the clafers, in pre-order.
+withUIDs :: [UID] -> IElement -> ([UID], IElement)
+withUIDs (uid' : uids) (IEClafer claf) = (uids', IEClafer claf{_uid = uid', _elements = elements'})
+  where (uids', elements') = mapAccumL withUIDs uids $ _elements claf
+withUIDs uids x = (uids, x)
+
+
+nameElement :: MonadState GEnv m => UID -> IElement -> m IElement
+nameElement puid x = case x of
+  IEClafer claf -> IEClafer <$> nameClafer puid claf
   IEConstraint isHard' pexp -> IEConstraint isHard' <$> namePExp pexp
   IEGoal isMaximize' pexp -> IEGoal isMaximize' <$> namePExp pexp
 
 
-nameClafer :: MonadState GEnv m => Bool -> UID -> IClafer -> m IClafer
-nameClafer skipResolver puid claf = do
+nameClafer :: MonadState GEnv m => UID -> IClafer -> m IClafer
+nameClafer puid claf = do
   let puid' = if _isAbstract claf && puid == "root" then baseClafer else puid
-  claf' <- if skipResolver then return claf{_uid = _ident claf, _parentUID = puid'} else renameClafer True puid' claf
-  elements' <- mapM (nameElement skipResolver (_uid claf')) $ _elements claf
-  return $ claf' {_elements = elements'}
+  elements' <- mapM (nameElement (_uid claf)) $ _elements claf
+  return $ claf {_parentUID = puid', _elements = elements'}
 
 
 namePExp :: MonadState GEnv m => PExp -> m PExp
@@ -89,13 +107,11 @@
 nameIDecl (IDecl isDisj' dels body') = IDecl isDisj' dels `liftM` (namePExp body')
 
 -- -----------------------------------------------------------------------------
-resolveNamesModule :: ClaferArgs -> (IModule, GEnv) -> Resolve (IModule, GEnv)
-resolveNamesModule args' (imodule, genv') =
+resolveNamesModule :: (IModule, GEnv) -> Resolve (IModule, GEnv)
+resolveNamesModule (imodule, genv') =
   do
     imodule' <- foldM (flip ($)) imodule $ map (\f -> flip (curry f) genv') funs
     return (imodule', genv'{uidClaferMap = createUidIClaferMap imodule'})
   where
   funs :: [(IModule, GEnv) -> Resolve IModule]
-  funs
-    | skip_resolver args' = [return . analyzeModule, resolveRedefinition, resolveTModule]
-    | otherwise = [ return . analyzeModule, resolveModuleNames, resolveRedefinition, resolveTModule]
+  funs = [ return . analyzeModule, resolveModuleNames, resolveRedefinition, resolveTModule, resolveRootModule]
diff --git a/src/Language/Clafer/Intermediate/ResolverInheritance.hs b/src/Language/Clafer/Intermediate/ResolverInheritance.hs
--- a/src/Language/Clafer/Intermediate/ResolverInheritance.hs
+++ b/src/Language/Clafer/Intermediate/ResolverInheritance.hs
@@ -24,7 +24,7 @@
 module Language.Clafer.Intermediate.ResolverInheritance where
 
 import           Control.Applicative
-import           Control.Lens  ((^.), (&), (%%~), (.~), traverse)
+import           Control.Lens  ((^.), (&), (%%~), (.~))
 import           Control.Monad
 import           Control.Monad.Except
 import           Control.Monad.State
@@ -33,9 +33,7 @@
 import           Data.Tree
 import           Data.List
 import qualified Data.Map as Map
-import           Data.StringMap (StringMap)
-import qualified Data.StringMap as SMap
-import           Prelude hiding (traverse)
+import           Prelude
 
 import           Language.ClaferT
 import           Language.Clafer.Common
@@ -43,15 +41,16 @@
 import           Language.Clafer.Intermediate.Intclafer
 import           Language.Clafer.Intermediate.ResolverName
 
-
 -- | Resolve Non-overlapping inheritance
 resolveNModule :: (IModule, GEnv) -> Resolve (IModule, GEnv)
 resolveNModule (imodule, genv') =
   do
     let
       unresolvedDecls = _mDecls imodule
-      abstractClafers = filter _isAbstract $ bfsClafers $ toClafers unresolvedDecls
-    resolvedDecls <- mapM (resolveNElement abstractClafers) unresolvedDecls
+      allClafers = bfsClafers $ toClafers unresolvedDecls
+      abstractClafers = filter _isAbstract allClafers
+      ancestors' = ancestorsIn allClafers
+    resolvedDecls <- mapM (resolveNElement allClafers ancestors' abstractClafers Nothing) unresolvedDecls
     let
       relocatedDecls = relocateTopLevelAbstractToParents resolvedDecls    -- F> Top-level abstract clafer extending a nested abstract clafer <https://github.com/gsdlab/clafer/issues/67> <F
       uidClaferMap' = createUidIClaferMap imodule{_mDecls = relocatedDecls}
@@ -64,10 +63,28 @@
              , uidClaferMap = createUidIClaferMap resolvedHierarchiesIModule}
       )
 
-resolveNClafer :: [IClafer] -> IClafer -> Resolve IClafer
-resolveNClafer abstractClafers clafer =
+-- | The clafer and its ancestors, nearest first, among the given clafers.
+ancestorsIn :: [IClafer] -> IClafer -> [IClafer]
+ancestorsIn clafers = go []
+  where
+    byUID = Map.fromList [ (_uid c, c) | c <- clafers ]
+    go visited c = c : case Map.lookup (_parentUID c) byUID of
+      Just p | _uid p `notElem` visited -> go (_uid c : visited) p
+      _                                 -> []
+
+-- | Resolves the super of the clafer, given its parent (with the resolved super).
+resolveNClafer :: [IClafer] -> (IClafer -> [IClafer]) -> [IClafer] -> Maybe IClafer -> IClafer -> Resolve IClafer
+resolveNClafer allClafers ancestors' abstractClafers parent clafer =
   do
-    (super', superIClafer')    <- resolveNSuper abstractClafers $ _super clafer
+    -- a clafer cannot extend itself <https://github.com/gsdlab/clafer/issues/86>
+    let abstractClafers' = filter ((/= _uid clafer) . _uid) abstractClafers
+    -- unless it redefines another clafer with its name <https://github.com/gsdlab/clafer/issues/77>
+    case _super clafer of
+      Just (PExp _ _ _ (IClaferId _ id' _ _))
+        | _isAbstract clafer && id' == _ident clafer && id' `notElem` map _ident abstractClafers'
+        -> throwError $ SemanticErr (_cinPos clafer) $ "ResolverInheritance: clafer " ++ _uid clafer ++ " inherits from itself"
+      _ -> return ()
+    (super', superIClafer')    <- resolveNSuper allClafers ancestors' abstractClafers' parent clafer $ _super clafer
     -- F> Top-level abstract clafer extending a nested abstract clafer <https://github.com/gsdlab/clafer/issues/67> F>
     let
       parentUID' =
@@ -78,34 +95,115 @@
             else _parentUID clafer
           Nothing               -> _parentUID clafer
     -- <F Top-level abstract clafer extending a nested abstract clafer <https://github.com/gsdlab/clafer/issues/67> <F
-    elements' <- mapM (resolveNElement abstractClafers) $ _elements clafer
-    return $ clafer {_super = super', _parentUID = parentUID', _elements = elements'}
-
+    elements' <- mapM (resolveNElement allClafers ancestors' abstractClafers (Just clafer{_super = super'})) $ _elements clafer
+    return $ clafer
+      { _super = super'
+      , _parentUID = parentUID'
+      , _modifiers = IClaferModifiers
+          (_isAbstract clafer)
+          (_isInitial clafer || (fromMaybe False $ _isInitial <$> superIClafer'))  -- the clafer is declared as initial or inherits it
+          (_isFinal clafer || (fromMaybe False $ _isFinal <$> superIClafer'))      -- the clafer is declared as final or inherits it
+          (_finalReferences $ _modifiers clafer)
+      , _elements = elements'
+      }
 
-resolveNSuper :: [IClafer] -> Maybe PExp -> Resolve (Maybe PExp, Maybe IClafer)
-resolveNSuper _ Nothing = return (Nothing, Nothing)
-resolveNSuper abstractClafers (Just (PExp _ pid' pos' (IClaferId _ id' _ _))) =
+resolveNSuper :: [IClafer] -> (IClafer -> [IClafer]) -> [IClafer] -> Maybe IClafer -> IClafer -> Maybe PExp -> Resolve (Maybe PExp, Maybe IClafer)
+resolveNSuper _ _ _ _ _ Nothing = return (Nothing, Nothing)
+resolveNSuper _ ancestors' abstractClafers parent _ (Just (PExp _ pid' pos' (IClaferId _ id' _ _))) =
     if isPrimitive id'
       then throwError $ SemanticErr pos' $ "Primitive types are not allowed as super types: " ++ id'
       else do
-        r <- resolveN pos' abstractClafers id'
-        (id'', [superClafer']) <- case r of
-          Nothing -> throwError $ SemanticErr pos' $ "No superclafer found: " ++ id'
+        r <- case inheritedSuper of
+          Just c  -> return $ Just (_uid c, [c])
+          Nothing -> resolveN pos' ancestors' abstractClafers id'
+        ~(id'', [superClafer']) <- case r of
+          Nothing -> throwError $ SemanticErr pos' ("No superclafer found: " ++ id')
           Just m  -> return m
-        return (Just $ PExp (Just $ TClafer [id'']) pid' pos' (IClaferId "" id'' (isTopLevel superClafer') (Just id''))
+        return (Just $ PExp (Just $ TClafer [id'']) pid' pos' (IClaferId "" id'' (isTopLevel superClafer') (GlobalBind id''))
                  , Just superClafer')
-resolveNSuper _ x = return (x, Nothing)
+  where
+    -- The nearest abstract clafer with the name among the children of the parent and the
+    -- children which the parent inherits, even if other abstract clafers have the name: a
+    -- sibling, e.g., `h : Head` next to `abstract Head : Head`, or, for a redefinition, e.g.,
+    -- `fa : fa -> T`, the inherited clafer (the clafer itself is not in abstractClafers).
+    inheritedSuper = listToMaybe
+      [ c | s <- maybe [] (\p -> p : superChain abstractClafers p) parent
+          , IEClafer c <- _elements s
+          , _isAbstract c
+          , _ident c == id'
+          , c `elem` abstractClafers ]
+-- A path, e.g., `h : Person.Head`, names an abstract clafer by the path to it: the first
+-- name is a clafer, and each next name is a child of the previous clafer, its own or,
+-- if it has none with the name, an inherited one. So `Ella.Head` is the `Head` that Ella
+-- redefines, e.g., with `Head : Head`, or else the `Head` of its super Person.
+resolveNSuper allClafers ancestors' abstractClafers _ clafer (Just (PExp _ pid' pos' exp'@(IFunExp "." _))) =
+    case pathNames exp' of
+      Nothing -> throwError $ SemanticErr pos'
+        "A super must be the name of an abstract clafer or a path to it, e.g., Person.Head"
+      Just [] -> throwError $ SemanticErr pos' "BUG: an empty path as a super"
+      Just names@(first : rest) -> do
+        let path' = intercalate "." names
+        start <- firstClafer path' first
+        superClafer' <- foldM (child path') start rest
+        when (_uid superClafer' == _uid clafer) $ throwError $ SemanticErr pos' $
+          "ResolverInheritance: clafer " ++ _uid clafer ++ " inherits from itself"
+        unless (_isAbstract superClafer') $ throwError $ SemanticErr pos' $
+          "No superclafer found: " ++ path' ++ " is not abstract, and only abstract clafers can be supers"
+        let id'' = _uid superClafer'
+        return ( Just $ PExp (Just $ TClafer [id'']) pid' pos' (IClaferId "" id'' (isTopLevel superClafer') (GlobalBind id''))
+               , Just superClafer')
+  where
+    pathNames :: IExp -> Maybe [String]
+    pathNames IClaferId{_sident = s} = Just [s]
+    pathNames (IFunExp "." [l, r]) = (++) <$> pathNames (_exp l) <*> pathNames (_exp r)
+    pathNames _ = Nothing
+    -- the first name of the path: the nearest enclosing clafer with the name, e.g., Ella
+    -- in `h : Ella.Head` under Ella, or else the only clafer with the name, preferring a
+    -- top-level one
+    firstClafer path' n = case filter ((== n) . _ident) (drop 1 $ ancestors' clafer) of
+      (c : _) -> return c
+      [] -> case filter ((== n) . _ident) allClafers of
+        [] -> throwError $ SemanticErr pos' $ "No superclafer found: no clafer " ++ n ++ " for " ++ path'
+        [c] -> return c
+        cs -> case filter isTopLevel cs of
+          [c] -> return c
+          _ -> throwError $ SemanticErr pos' $ "No superclafer found: the clafer " ++ n ++ " in " ++ path'
+                 ++ " is not unique. Available paths:\n" ++ concatMap (pathOf . ancestors') cs
+    pathOf cs = intercalate "." (reverse $ map _ident cs) ++ "\n"
+    -- the child with the name, the clafer's own or else the nearest inherited one
+    child path' c n = case [ e | s <- c : superChain abstractClafers c, IEClafer e <- _elements s, _ident e == n ] of
+      (e : _) -> return e
+      [] -> throwError $ SemanticErr pos' $ "No superclafer found: " ++ _ident c
+              ++ " has no child " ++ n ++ ", neither its own nor an inherited one, for " ++ path'
+resolveNSuper _ _ _ _ _ x = return (x, Nothing)
 
+-- | The abstract supers of the clafer, nearest first. A super is found by its
+-- uid when resolved, or by its name when it is unique.
+superChain :: [IClafer] -> IClafer -> [IClafer]
+superChain abstractClafers = go []
+  where
+    go visited c = case getSuper c of
+      [s] | Just sup <- find ((== s) . _uid) abstractClafers <|> unique s
+          , _uid sup `notElem` visited
+          -> sup : go (_uid sup : visited) sup
+      _   -> []
+    unique s = case filter ((== s) . _ident) abstractClafers of
+      [sup] -> Just sup
+      _     -> Nothing
 
-resolveNElement :: [IClafer] -> IElement -> Resolve IElement
-resolveNElement abstractClafers x = case x of
-  IEClafer clafer  -> IEClafer <$> resolveNClafer abstractClafers clafer
+
+resolveNElement :: [IClafer] -> (IClafer -> [IClafer]) -> [IClafer] -> Maybe IClafer -> IElement -> Resolve IElement
+resolveNElement allClafers ancestors' abstractClafers parent x = case x of
+  IEClafer clafer  -> IEClafer <$> resolveNClafer allClafers ancestors' abstractClafers parent clafer
   IEConstraint _ _  -> return x
   IEGoal _ _ -> return x
 
-resolveN :: Span -> [IClafer] -> String -> Resolve (Maybe (String, [IClafer]))
-resolveN pos' abstractClafers id' =
-  findUnique pos' id' $ map (\x -> (x, [x])) abstractClafers
+-- | The abstract clafer with the name. An ambiguous name is an error which shows the
+--   paths of the candidates, e.g., @A.A__T@ and @B.B__T@, and two candidates in the same
+--   namespace are a duplicate definition.
+resolveN :: Span -> (IClafer -> [IClafer]) -> [IClafer] -> String -> Resolve (Maybe (String, [IClafer]))
+resolveN pos' ancestors' abstractClafers id' =
+  fmap (fmap $ fmap $ take 1) $ findUnique pos' id' $ map (\x -> (x, ancestors' x)) abstractClafers
 
 
 resolveHierarchy :: UIDIClaferMap -> IElement           -> Resolve IElement
@@ -142,7 +240,7 @@
 
 resolveOReference :: SEnv -> Maybe IReference -> Resolve (Maybe IReference)
 resolveOReference _   Nothing                      = return Nothing
-resolveOReference env (Just (IReference is' exp')) = Just <$> IReference is' <$> resolvePExp env exp'
+resolveOReference env (Just (IReference is' mods exp')) = Just <$> IReference is' mods <$> resolvePExp env exp'
 
 
 resolveOElement :: SEnv -> IElement -> Resolve IElement
@@ -183,10 +281,11 @@
   where
   card'
     | _isAbstract clafer = (0, -1)
-    | (isJust $ context env) && pGcard == (0, -1)
+    -- mandatory under the default group; optional under a keyword group (opt included) or a numeric one
+    | (isJust $ context env) && pGcard == IGCard False (0, -1)
       || (isTopLevel clafer) = (1, 1)
     | otherwise = (0, 1)
-  pGcard = _interval $ fromJust $ _gcard $ fromJust $ context env
+  pGcard = fromJust $ _gcard $ fromJust $ context env
 
 analyzeElement :: SEnv -> IElement -> IElement
 analyzeElement env x = case x of
@@ -228,8 +327,8 @@
 getDirUnrollables dependencies = (filter isUnrollable $ map (map v2n) $
                                   map flatten (scc graph)) >>= map fst3
   where
-  (graph, v2n, _) = graphFromEdges $map (\(c, ss) -> (c, c, ss)) dependencies
-  isUnrollable (x:[]) = fst3 x `elem` trd3 x
+  (graph, v2n, _) = graphFromEdges $ map (\(c, ss) -> (c, c, ss)) dependencies
+  isUnrollable [x] = fst3 x `elem` trd3 x
   isUnrollable _ = True
 
 -- -----------------------------------------------------------------------------
@@ -256,14 +355,19 @@
 
 renameClafer' :: MonadState GEnv m => UID -> IClafer -> m IClafer
 renameClafer' puid clafer = do
-  let claferIdent = _ident clafer
+  -- a copy of an inherited clafer (-i): the UID of the original with the first suffix __2,
+  -- __3, ... that no clafer has (see Language.Clafer.Intermediate.UIDs)
+  let original = _uid clafer
   identCountMap' <- gets identCountMap
-  let count = Map.findWithDefault 0 claferIdent identCountMap'
-  modify (\e -> e { identCountMap = Map.alter (\_ -> Just (count+1)) claferIdent identCountMap' } )
-  return $ clafer { _uid = genId claferIdent count, _parentUID = puid }
+  uidClaferMap' <- gets uidClaferMap
+  let count = Map.findWithDefault 1 original identCountMap'
+      taken n = isJust $ findIClafer uidClaferMap' (copyId original n)
+      n' = head [ n | n <- [count + 1 ..], not (taken n) ]
+  modify (\e -> e { identCountMap = Map.insert original n' identCountMap' } )
+  return $ clafer { _uid = copyId original n', _parentUID = puid }
 
-genId :: String -> Int -> String
-genId id' count = concat ["c", show count, "_",  id']
+copyId :: String -> Int -> String
+copyId id' n = id' ++ "__" ++ show n
 
 resolveEInheritance :: MonadState GEnv m => [String] -> [String] -> Bool -> [IElement] -> [IClafer]  -> m ([IElement], Maybe PExp, [IClafer])
 resolveEInheritance predecessors unrollables absAncestor declarations allSuper = do
@@ -332,16 +436,16 @@
     needsRelocation    _                  = False
 
     -- creates a map from parentUID to a list of elements to be added as children of a clafer with that UID
-    mkParentUIDIElementMap :: [IElement] -> StringMap [IElement]
+    mkParentUIDIElementMap :: [IElement] -> Map.Map UID [IElement]
     mkParentUIDIElementMap    elems       = foldl'
-        (\accumMap' (parentUID', elem') -> SMap.insertWith (++) parentUID' [elem'] accumMap')
-        SMap.empty
+        (\accumMap' (parentUID', elem') -> Map.insertWith (++) parentUID' [elem'] accumMap')
+        Map.empty
         (map (\e -> (_parentUID $ _iClafer e, e)) elems)
 
-    insertElements :: StringMap [IElement] -> IElement     -> IElement
+    insertElements :: Map.Map UID [IElement] -> IElement     -> IElement
     insertElements    parentMap               targetElement = let
         targetUID = targetElement ^. iClafer . uid
-        newChildren = SMap.findWithDefault [] targetUID parentMap
+        newChildren = Map.findWithDefault [] targetUID parentMap
         currentElements = targetElement ^. iClafer . elements
         newElements =  map (insertElements parentMap) currentElements
                     ++ newChildren
diff --git a/src/Language/Clafer/Intermediate/ResolverName.hs b/src/Language/Clafer/Intermediate/ResolverName.hs
--- a/src/Language/Clafer/Intermediate/ResolverName.hs
+++ b/src/Language/Clafer/Intermediate/ResolverName.hs
@@ -28,6 +28,8 @@
 import Control.Monad.Except
 import Control.Monad.Trans.Maybe
 import Control.Monad.State
+import Control.Lens.Plated (transformOn)
+import Data.Data.Lens (biplate)
 import Data.Maybe
 import Data.Function
 import Data.List
@@ -49,15 +51,18 @@
   , genv :: GEnv                         -- (constant)
   , aClafers :: [(IClafer, [IClafer])]   -- (constant) abstract clafers (BFS)
   , cClafers :: [(IClafer, [IClafer])]   -- (constant) all concrete clafers (BFS)
+  , parentEnv :: Maybe SEnv              -- the environment of the parent of the context, where
+                                         -- the value of an initializer is resolved ('iInitValue')
   } deriving Show
 
 -- | How a given name was resolved
 data HowResolved
-  = Special     -- ^ "this", "parent", "dref", "root", "clafer", and "children"
+  = Special     -- ^ "this", "parent", "dref", "root", "clafer", "children" and "noclafer"
   | TypeSpecial -- ^ primitive type: "integer", "string"
   | Binding     -- ^ local variable (in constraints)
   | Subclafers  -- ^ clafer's descendant
   | Reference   -- ^ resolved by a reference
+  | TargetChild -- ^ child of the target of the reference clafer (the context)
   | Ancestor    -- ^ clafer's ancestor
   | AbsClafer   -- ^ abstract clafer
   | TopClafer   -- ^ non-abstract top-level clafer
@@ -70,7 +75,7 @@
 defSEnv genv' declarations = env {aClafers = rCl aClafers',
                                  cClafers = rCl cClafers'}
   where
-  env = SEnv (toClafers declarations) Nothing [] [] [] [] genv' [] []
+  env = SEnv (toClafers declarations) Nothing [] [] [] [] genv' [] [] Nothing
   rCl cs = bfs toNodeDeep $ map (\c -> env{context = Just c, resPath = [c]}) cs
   (aClafers', cClafers') = partition _isAbstract $ clafers env
 
@@ -120,14 +125,15 @@
 resolveClafer :: SEnv -> IClafer -> Resolve IClafer
 resolveClafer env clafer =
   do
-    elements' <- mapM (resolveElement env'{subClafers = subClafers',
-                                              ancClafers = ancClafers'}) $
+    elements' <- mapM (resolveElement env'{ subClafers = subClafers'
+                                          , ancClafers = ancClafers'
+                                          , parentEnv = Just env}) $
                           _elements clafer
     return $ clafer {_elements = elements'}
   where
   env' = env {context = Just clafer, resPath = clafer : resPath env}
   subClafers' = tail $ bfs toNodeDeep [env'{resPath = [clafer]}]
-  ancClafers' = init (tails $ resPath env) >>= (mkAncestorList env)
+  ancClafers' = init (tails $ resPath env) >>= mkAncestorList env
 
 mkAncestorList :: SEnv -> [IClafer] -> [(IClafer, [IClafer])]
 mkAncestorList env rp =
@@ -148,15 +154,42 @@
     return pexp{_exp=exp'}
 
   IFunExp "." _ -> fst <$> resolveNav env pexp True
+  -- the value of an initializer, which the desugarer moved into the context of the clafer
+  -- from that of its parent: it keeps the meaning it has in the context of the parent
+  IFunExp op' [value] | op' == iInitValue -> case parentEnv env of
+    Just penv -> do
+      value' <- fromParent (_inPos value) (context env) <$> resolvePExp penv value
+      -- a value with temporal operators keeps the marker: its obligations are bounded by the
+      -- lifetime of the parent of the parent, and initially and finally refer to the lifetime of
+      -- the parent, as where the value is written (gsdlab/clafer#123); the temporal generator
+      -- evaluates it in the context of the parent ('AlloyLtl')
+      return $ if hasLtlOps value' then pexp{_exp = IFunExp iInitValue [value']} else value'
+    Nothing -> throwError $ SemanticErr (_inPos pexp) "BUG: the value of an initializer outside a clafer"
   IFunExp op' exps' -> do
                          exp' <- IFunExp op' <$> mapM (resolvePExp env) exps'
                          return $ pexp {_exp = exp'}
   IInt _ -> return pexp
   IDouble _ -> return pexp
+  IDecimal _ -> return pexp
   IReal _ -> return pexp
   IStr _ -> return pexp
   IClaferId{} -> fst <$> resolveNav env pexp True
 
+-- | An expression resolved in the context of the parent of the clafer @x@, rewritten for the
+--   context of @x@: @this@, the instance of the parent, becomes @this.parent@, or the root if @x@
+--   is a top-level clafer. The other names are already resolved to absolute paths or to paths
+--   from @this@.
+fromParent :: Span -> Maybe IClafer -> PExp -> PExp
+fromParent pos' ctx = transformOn biplate fromThis
+  where
+  fromThis :: IExp -> IExp
+  fromThis IClaferId{_sident = s} | s == thisIdent = case ctx of
+    Just c | _parentUID c /= rootIdent && _parentUID c /= baseClafer ->
+      IFunExp iJoin [ pExpDefPid pos' $ IClaferId "" thisIdent True (createBind ctx)
+                    , mkPLClaferId pos' parentIdent False (GlobalBind $ _parentUID c) ]
+    _ -> rootIExp
+  fromThis e = e
+
 liftError :: Monad m => Either e a -> ExceptT e m a
 liftError = ExceptT . return
 
@@ -170,53 +203,123 @@
 resolveNav :: SEnv -> PExp                         -> Bool   -> Resolve (PExp, [IClafer])
 resolveNav    env     pexp0@PExp{_inPos=pos', _exp=x} isFirst =
   case x of
+    -- a navigation from the empty set is empty, whatever it navigates to, so the names after
+    -- `noclafer` are not resolved; the compiler warns about it
+    IFunExp "." [pexp1, _] | fromNoClafer pexp1 -> return (pexp0{_exp = noClaferIExp}, [])
     IFunExp "." [pexp1,pexp2] -> do
       (pexp1', path1) <- resolveNav env                                               pexp1 True
       (pexp2', path2) <- resolveNav env{context = listToMaybe path1, resPath = path1} pexp2 False
       -- if `dref` was added to the RHS we need to left rotate the tree
       case pexp2' of
         PExp{_exp=IFunExp "." [pexp2'l, pexp2'r]} -> case pexp2'l of
+          -- after an explicit `dref`, e.g., to a union of clafers, a name of its target needs
+          -- no second `dref`
+          PExp{_exp=IClaferId{_sident="dref"}} | endsWithDref pexp1' ->
+            return (pexp0{_exp=IFunExp iJoin [pexp1', pexp2'r]}, path2)
           PExp{_exp=IClaferId{_sident="dref"}} ->
             let -- move the `dref` to the LHS
               pexp0' = pexp0{_exp=IFunExp iJoin [pexp1', pexp2'l]}
             in -- keep the RHS as is
               return (pexp2{_exp=IFunExp iJoin [pexp0', pexp2'r]}, path2)
           _ -> return (pexp0{_exp=IFunExp iJoin [pexp1', pexp2']}, path2)
+        -- the parent of an instance of a top-level clafer is the root (#112); that of another set
+        -- of instances is the root when the set is not empty, which ResolverRoot decides
+        PExp{_exp=IClaferId{_sident="parent"}} | Just c <- listToMaybe path1, isRootChild c, isSingleInstance pexp1' ->
+          return (pexp0{_exp=rootIExp}, [])
         _ -> return (pexp0{_exp=IFunExp iJoin [pexp1', pexp2']}, path2)
+    -- a navigation from an intersection or a difference of sets, e.g., (this ** g.f2).parent,
+    -- which ResolverRoot writes for a split constraint (#112) and an explicit model keeps: the
+    -- set is in the right operand of `**` and in the left of `--`, whose path the navigation
+    -- continues from
+    IFunExp op' [l, r] | op' == iIntersection || op' == iDifference -> do
+      (l', pathL) <- resolveNav env l True
+      (r', pathR) <- resolveNav env r True
+      return (pexp0{_exp = IFunExp op' [l', r']}, if op' == iIntersection then pathR else pathL)
     IClaferId _ "root" _ _ -> return (pexp0, [])
+    IClaferId _ "noclafer" _ _ -> return (pexp0{_exp = noClaferIExp}, [])
+    -- clafer as a value, the union of all clafers, which ResolverRoot writes out
+    IClaferId _ "clafer" _ _ | isFirst -> return (pexp0{_exp = IClaferId "" baseClafer True (GlobalBind baseClafer)}, [])
     IClaferId modName' id' _ _ -> if isFirst
       then do
              (exp', path') <- mkPath pos' env <$> resolveName pos' env id'
-             return (pexp0{_exp=exp'}, path')
+             return (pexp0{_exp=exp'}, derefPath env id' path')
       else do
              (exp', path') <- case resPath env of
                [] -> mkPath' pos' modName' <$> resolveTopLevelName pos' env id'
                _  -> mkPath' pos' modName' <$> resolveImmName pos' env id'
-             return (pexp0{_exp=exp'}, path')
+             return (pexp0{_exp=exp'}, derefPath env id' path')
     y -> throwError $ SemanticErr pos' $ "Cannot resolve nav of " ++ show y
 
+-- | A concrete top-level clafer, whose parent is the root. The root is synthetic: it has no
+--   instance in the outputs, and a navigation from it is a navigation from the top level.
+isRootChild :: IClafer -> Bool
+isRootChild c = _parentUID c == rootIdent && not (_isAbstract c)
+
+-- | @this@ or a variable: one instance, whose parent always exists. The parent of a set of
+--   instances of a top-level clafer is the root only when the set is not empty.
+isSingleInstance :: PExp -> Bool
+isSingleInstance PExp{_exp=IClaferId{_sident=s}} | s == thisIdent = True
+isSingleInstance PExp{_exp=IClaferId{_binding=LocalBind _}} = True
+isSingleInstance _ = False
+
+rootIExp :: IExp
+rootIExp = IClaferId "" rootIdent True (GlobalBind rootIdent)
+
+noClaferIExp :: IExp
+noClaferIExp = IClaferId "" noClaferIdent True (GlobalBind noClaferIdent)
+
+-- | A navigation that starts at @noclafer@, e.g., @noclafer@ in @noclafer.d.e@, before resolution
+fromNoClafer :: PExp -> Bool
+fromNoClafer PExp{_exp = IFunExp "." [l, _]} = fromNoClafer l
+fromNoClafer p = isNoClafer p
+
+endsWithDref :: PExp -> Bool
+endsWithDref PExp{_exp=IClaferId{_sident=s}} = s == drefIdent
+endsWithDref PExp{_exp=IFunExp "." [_, r]} = endsWithDref r
+endsWithDref _ = False
+
+-- | After @dref@, the path continues at the target of the reference, which a clafer declares or
+--   inherits, so that the names after it are the target's children: @this.dref.speed@ under
+--   @l -> Port@ is the @speed@ of the port, not @this.dref.dref.speed@. A reference to a union
+--   of clafers has no single target, and the path stays at the reference clafer.
+derefPath :: SEnv -> String -> [IClafer] -> [IClafer]
+derefPath env id' path
+  | id' == drefIdent, c : _ <- path
+  , [target] : _ <- filter (not . null) $ mapHierarchy getReference getSuper uidMap c
+  , Just t <- findIClafer uidMap target
+  = t : path
+  | otherwise = path
+  where
+  uidMap = uidClaferMap $ genv env
+
 -- | Depending on how resolved construct a navigation path from 'context env'
 mkPath :: Span -> SEnv -> (HowResolved, String, [IClafer]) -> (IExp, [IClafer])
 mkPath    pos'    env     (howResolved, id',    path)       = case howResolved of
-  Binding -> (IClaferId "" id' True Nothing, path)
+  Binding -> (IClaferId "" id' True (LocalBind id'), path)
   Special -> (specIExp id', path)
-  TypeSpecial -> (IClaferId "" id' True (Just id'), path)
+  TypeSpecial -> (IClaferId "" id' True (GlobalBind id'), path)
   Subclafers -> (toNav $ tail $ reverse $ map toTuple path, path)
   Ancestor -> (toNav' pos' $ adjustAncestor (fromJust $ context env)
                                        (reverse $ map toTuple $ resPath env)
                                        (reverse $ map toTuple path), path)
   Reference -> (toNav' pos' $ reverse $ map toTuple path, path)
+  TargetChild -> (toNav [("dref", context env), (id', Just $ head path)], path)
   AbsClafer -> (toNav' pos' $ reverse $ map toTuple path, path)
   TopClafer -> (toNav' pos' $ reverse $ map toTuple path, path)
   where
   toNav tuplePath = foldl'
-          (\exp' (id'', cbind) -> IFunExp iJoin [pExpDefPid pos' exp', mkPLClaferId pos' id'' (fromMaybe False $ isTopLevel <$> cbind) $ _uid <$> cbind])
-          (IClaferId "" thisIdent True (_uid <$> context env))
+          (\exp' (id'', cbind) -> IFunExp iJoin [pExpDefPid pos' exp', mkPLClaferId pos' id'' False $ createBind cbind])
+          (IClaferId "" thisIdent True (createBind $ context env))
           tuplePath
-  specIExp "this"     = IClaferId "" thisIdent True (_uid <$> context env)
-  specIExp "parent"   = toNav [("parent", Just $ head path)]
+  specIExp "this"     = IClaferId "" thisIdent True (createBind $ context env)
+  -- at the top level, the parent of a concrete clafer is the root (#112); that of an abstract
+  -- one is the parent of the instances of its subclafers
+  specIExp "parent"   = case (path, context env) of
+    ([], Just c) | isRootChild c -> rootIExp
+    _ -> toNav [("parent", listToMaybe path)]
   specIExp "dref"     = toNav [("dref", Just $ head path)]
-  specIExp "root"     = IClaferId "" rootIdent True (Just rootIdent)
+  specIExp "root"     = IClaferId "" rootIdent True (GlobalBind rootIdent)
+  specIExp "noclafer" = noClaferIExp
   specIExp "children" = toNav [(id', Just $ head path)]
   specIExp i          = error $ "[BUG] ResolverName.specIExp: Unknown special id: " ++ i
 
@@ -225,24 +328,33 @@
 
 toNav' :: Span -> [(String, Maybe IClafer)] -> IExp
 toNav'    pos'    tuplePath                  =
-  (mkIFunExp pos' iJoin $ map (\(id', cbind) -> IClaferId "" id' (fromMaybe False $ isTopLevel <$> cbind) (_uid <$> cbind)) tuplePath) :: IExp
+  (mkIFunExp pos' iJoin $ map (\(id', cbind) -> IClaferId "" id' (fromMaybe False $ isTopLevel <$> cbind) (createBind cbind)) tuplePath) :: IExp
 
+createBind :: Maybe IClafer -> ClaferBinding
+createBind (Just c) = GlobalBind $ _uid c
+createBind _ = NoBind
+
 adjustAncestor :: IClafer -> [(String, Maybe IClafer)] -> [(String, Maybe IClafer)] -> [(String, Maybe IClafer)]
 adjustAncestor ctx cPath rPath = (thisIdent, Just ctx) : parents ++ (fromJust $ stripPrefix prefix rPath)
   where
-  parents = replicate (length $ fromJust $ stripPrefix prefix cPath) (parentIdent, Nothing)
+  {-parents = replicate (length $ fromJust $ stripPrefix prefix cPath) (parentIdent, Nothing)-}
+  parents = map createParent $ fromJust $ stripPrefix prefix cPath
+  createParent :: (String, Maybe IClafer) -> (String, Maybe IClafer)
+  createParent (_, clafer) = (parentIdent, clafer)
   prefix = fst $ unzip $ takeWhile (uncurry eqIds) $ zip cPath rPath
   eqIds a b = (fst a) == (fst b)
 
 
 mkPath' :: Span -> String -> (HowResolved, String, [IClafer]) -> (IExp, [IClafer])
 mkPath'    pos' modName'  (howResolved, id', path)          = case howResolved of
-  Reference -> (toNav' pos' (zip ["dref", id'] (map Just path)), path)
-  _ -> (IClaferId modName' id' False (_uid <$> bind), path)
+  -- the path is [the child, the reference clafer]: dref belongs to the reference clafer
+  Reference -> (toNav' pos' (zip ["dref", id'] (map Just $ reverse path)), path)
+  -- a top-level clafer after `root.` (#112)
+  _ -> (IClaferId modName' id' (maybe False isTopLevel $ listToMaybe path) bind, path)
   where
-    bind = case path of
-      [] -> Nothing
-      c:_ -> Just c
+  bind = case path of
+    [] -> NoBind
+    c:_ -> GlobalBind $ _uid c
 
 -- -----------------------------------------------------------------------------
 
@@ -252,7 +364,7 @@
 
 resolveName :: Span -> SEnv -> String -> Resolve (HowResolved, String, [IClafer])
 resolveName pos' env id' = resolve env id'
-  [resolveSpecial, resolveBind, resolveDescendants, resolveAncestor pos', resolveTopLevel pos', resolveNone pos']
+  [resolveSpecial, resolveBind, resolveDescendants, resolveAncestor pos', resolveTargetChild pos', resolveTopLevel pos', resolveNone pos']
 
 
 resolveImmName :: Span -> SEnv -> String -> Resolve (HowResolved, String, [IClafer])
@@ -274,7 +386,7 @@
     , "' not found within paths:"
     , showPath $ map _uid $ resPath env
     , "in context of '"
-    , show $ fromMaybe "none" (_uid <$> context env)
+    , show $ maybe "none" _uid (context env)
     , "'" ]
 
 
@@ -296,12 +408,22 @@
 -- searches for a name in all subclafers (BFS)
 resolveDescendants :: SEnv -> String -> Resolve (Maybe (HowResolved, String, [IClafer]))
 resolveDescendants env id' = return $
-  (context env) >> (findFirst id' $ subClafers env) >>= (toMTriple Subclafers)
+  context env >> findFirst id' (subClafers env) >>= toMTriple Subclafers
 
 -- searches for a name in immediate subclafers (BFS)
 resolveChildren :: Span -> SEnv -> String -> Resolve (Maybe (HowResolved, String, [IClafer]))
 resolveChildren pos' env id' = resolveChildren' pos' env id' allInhChildren Subclafers
 
+-- searches for a name among the children of the target of the reference clafer
+-- which is the context, e.g., machine in `services -> Service` with `Service`
+-- having a child `machine`, which becomes this.dref.machine
+resolveTargetChild :: Span -> SEnv -> String -> Resolve (Maybe (HowResolved, String, [IClafer]))
+resolveTargetChild pos' env id' = case context env of
+  Just IClafer{_reference = Just _} -> resolveChildren' pos' env id' targetChildren TargetChild
+  _                                 -> return Nothing
+  where
+  targetChildren env' = allChildren env' \\ allInhChildren env'
+
 -- searches for a name by dereferencing clafer
 resolveReference :: Span -> SEnv -> String -> Resolve (Maybe (HowResolved, String, [IClafer]))
 resolveReference pos' env id' = resolveChildren' pos' env id' allChildren Reference
@@ -373,7 +495,7 @@
     [elem'] -> return $ Just (_uid $ fst elem', snd elem')
     xs'    -> throwError $ SemanticErr pos' $ "clafer " ++ show x ++ " " ++ errMsg
       where
-      xs''   = map ((map _uid).snd) xs'
+      xs''   = map (map _uid.snd) xs'
       errMsg = (if isNamespaceConflict xs''
                then "cannot be defined because the name should be unique in the same namespace.\n"
                else "is not unique. ") ++
@@ -386,7 +508,7 @@
     (ele:_) -> Just $ (_uid $ fst ele, snd ele)
 
 showPath :: [String] -> String
-showPath xs = (intercalate "." $ reverse xs) ++ "\n"
+showPath xs = intercalate "." (reverse xs) ++ "\n"
 
 isNamespaceConflict :: [[String]] -> Bool
 isNamespaceConflict (xs:ys:_) = tail xs == tail ys
@@ -394,4 +516,4 @@
                                          ++ " of at least two elements, but was given " ++ show x
 
 filterPaths :: String -> [(IClafer, [IClafer])] -> [(IClafer, [IClafer])]
-filterPaths x xs = filter (((==) x)._ident.fst) xs
+filterPaths x = filter ((==) x._ident.fst)
diff --git a/src/Language/Clafer/Intermediate/ResolverRoot.hs b/src/Language/Clafer/Intermediate/ResolverRoot.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Clafer/Intermediate/ResolverRoot.hs
@@ -0,0 +1,255 @@
+{-
+ Copyright (C) 2026 Michal Antkiewicz <http://gsd.uwaterloo.ca>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-}
+-- | The synthetic root (#112). The root is the parent of the instances of the top-level
+--   concrete clafers, but it has no instance in the outputs: a navigation from it is a
+--   navigation from the top level (@root.a@ is @a@), which the generators translate. Here,
+--   after the types are resolved:
+--
+--   This applies to static models: in temporal models, the root is a signature.
+--
+--   * the root as a value is a constant: @some root@, @one root@ and @lone root@ hold, @no root@
+--     does not, and @#root@ is 1; any other use of it as a value is an error;
+--   * the parent of a set of instances of top-level clafers is the root when the set is not
+--     empty: @some a.parent@ is @some a@, @#a.parent@ is 1 or 0, a navigation from it is a
+--     navigation from the root when @a@ exists, and @a.parent@ is the root when @a@ always
+--     exists;
+--   * a constraint of a top-level abstract clafer that takes the parent of @this@, when some of
+--     its subclafers are at the top level and some nested, is split on @this@: for the
+--     instances of the top-level subclafers, the parent is the root.
+module Language.Clafer.Intermediate.ResolverRoot (resolveRootModule) where
+
+import Control.Lens.Plated (universeOn)
+import Control.Monad
+import Control.Monad.Except
+import Data.Data.Lens (biplate)
+import Data.Maybe (isNothing)
+import qualified Data.Map as Map
+
+import Language.ClaferT
+import Language.Clafer.Front.AbsClafer (noSpan)
+import Language.Clafer.Common
+import Language.Clafer.Intermediate.Intclafer
+import Language.Clafer.Intermediate.TypeSystem (rootTClafer, noClaferTClafer, (+++))
+
+type Resolve = Either ClaferSErr
+
+-- | Whether the parent of @this@ is the root, in one part of a split constraint.
+data ThisParent = Unsplit | RootParent | NestedParent IClafer
+
+resolveRootModule :: (IModule, GEnv) -> Resolve IModule
+resolveRootModule (imodule, _)
+  -- the temporal generator has a root signature, and the parent of an instance of a top-level
+  -- abstract clafer is the root for those of its top-level subclafers there
+  | isDynamicModule imodule = case [ p | p@PExp{_exp = IClaferId{_sident = s}} <- universeOn biplate imodule, s == baseClafer ] of
+    -- the instances of the clafers change over a trace
+    p : _ -> throwError $ SemanticErr (_inPos p) "`clafer` as a value, the union of all clafers, is not supported in temporal models"
+    [] -> return imodule
+  | otherwise = do
+    decls' <- mapM (rootElement Nothing) $ _mDecls imodule
+    return imodule{_mDecls = decls'}
+  where
+  uidMap = createUidIClaferMap imodule
+  -- the clafers with no super clafer, whose union is all clafers, in the order of the model
+  topClafers = [ c | c <- universeOn biplate imodule, isNothing (_super c), _uid c `notElem` [rootIdent, baseClafer] ]
+
+  rootElement :: Maybe IClafer -> IElement -> Resolve IElement
+  rootElement _ (IEClafer c) = do
+    elements' <- mapM (rootElement $ Just c) $ _elements c
+    return $ IEClafer c{_elements = elements'}
+  rootElement ctx (IEConstraint isHard' pexp) = IEConstraint isHard' <$> rootConstraint ctx pexp
+  rootElement ctx (IEGoal isMaximize' pexp) = IEGoal isMaximize' <$> rootPExp ctx Unsplit pexp
+
+  rootConstraint :: Maybe IClafer -> PExp -> Resolve PExp
+  rootConstraint ctx@(Just c) pexp
+    | ParentMixed tops nested <- parentKind (_uid c), takesParentOfThis pexp = do
+      onTop <- rootPExp ctx RootParent pexp
+      onNested <- mapM (\n -> rootPExp ctx (NestedParent n) pexp) nested
+      let bool = PExp (Just TBoolean) "" noSpan
+          implies cs e = bool $ IFunExp iImpl [bool $ IFunExp iIn [thisOf c, unionOf cs], e]
+      return pexp{_exp = _exp $ foldl1 (\l r -> bool $ IFunExp iAnd [l, r]) $
+        implies tops onTop : zipWith (\n e -> implies [n] e) nested onNested}
+  rootConstraint ctx pexp = rootPExp ctx Unsplit pexp
+
+  -- the concrete subclafers of a clafer, at the top level and nested
+  parentKind :: UID -> ParentKind
+  parentKind uid'
+    | null tops = ParentReal
+    | null nested = ParentRoot
+    | otherwise = ParentMixed tops nested
+    where
+    subs = [ c' | c' <- Map.elems uidMap, not (_isAbstract c'), _uid c' /= rootIdent
+                , uid' `elem` map _uid (tail $ findHierarchy getSuper uidMap c') ]
+    (tops, nested) = (filter isRootChild subs, filter (not . isRootChild) subs)
+
+  isRootChild c' = _parentUID c' == rootIdent && not (_isAbstract c')
+
+  thisOf c = PExp (Just $ TClafer [_uid c]) "" noSpan $ IClaferId "" thisIdent True (GlobalBind $ _uid c)
+  -- all the instances of the clafers, a nested one by its path from the top level, e.g., g.f2
+  unionOf cs = foldl1 (\l r -> PExp (Just $ TClafer []) "" noSpan $ IFunExp iUnion [l, r]) $ map instancesOf cs
+  instancesOf c' = foldl1 (\l r -> PExp (_iType r) "" noSpan $ IFunExp iJoin [l, r])
+    [ PExp (Just $ TClafer [_uid a]) "" noSpan $ IClaferId "" (_uid a) (isTopLevel a) (GlobalBind $ _uid a) | a <- reverse $ ancestors c' ]
+  ancestors c' = c' : case findIClafer uidMap $ _parentUID c' of
+    Just p | not (isTopLevel c'), _uid p /= rootIdent -> ancestors p
+    _ -> []
+
+  rootPExp :: Maybe IClafer -> ThisParent -> PExp -> Resolve PExp
+  rootPExp ctx split pexp@PExp{_inPos = pos', _exp = exp'} = case exp' of
+    IFunExp op' [l, r@PExp{_exp = IClaferId{_sident = s}}] | op' == iJoin, s == parentIdent -> do
+      l' <- rootPExp ctx split l
+      case parentKindOf l' of
+        Just ParentRoot | isSingle l' || alwaysExists l' -> return $ toRoot pexp
+        Just (ParentMixed _ _) | isThis l', RootParent <- split -> return $ toRoot pexp
+        -- this as an instance of one nested subclafer, whose parent Choco can take: that of
+        -- the abstract clafer, or of a union of clafers, it cannot
+        Just (ParentMixed _ _) | isThis l', NestedParent n <- split ->
+          return pexp{_exp = IFunExp op' [l'{_exp = IFunExp iIntersection [l', unionOf [n]]}, r]}
+        Just ParentRoot -> throwError $ SemanticErr pos' $
+          "The parent of " ++ claferNames l' ++ " is the root when an instance exists, and nothing otherwise: it can be navigated from, quantified or counted, e.g., `" ++ claferNames l' ++ ".parent.a`, `some " ++ claferNames l' ++ ".parent` or `#" ++ claferNames l' ++ ".parent`"
+        Just (ParentMixed tops _) -> throwError $ SemanticErr pos' $
+          "The parent of an instance of " ++ claferNames l' ++ " is the root for its top-level subclafers (" ++ unwords (map _ident tops) ++ ") and an instance for the others: take the parent of `this` in a constraint of " ++ claferNames l'
+        _ -> return pexp{_exp = IFunExp op' [l', r]}
+    -- a navigation from the parent of a set of instances of top-level clafers, e.g.,
+    -- extra.parent.a for extra ?, is the navigation from the root when an instance exists:
+    -- if some extra then a else noclafer
+    IFunExp op' [PExp{_exp = IFunExp op'' [l, PExp{_exp = IClaferId{_sident = s}}]}, r]
+      | op' == iJoin, op'' == iJoin, s == parentIdent, Just ParentRoot <- parentKindOf l, not (isSingle l || alwaysExists l) -> do
+      l' <- rootPExp ctx split l
+      r' <- rootPExp ctx split r
+      let nav = pexp{_pid = "", _exp = IFunExp iJoin [toRoot l', r']}
+      let noClafer = PExp (Just noClaferTClafer) "" noSpan $ IClaferId "" noClaferIdent True (GlobalBind noClaferIdent)
+      return pexp{_exp = IFunExp iIfThenElse [exists l', nav, noClafer]}
+    IFunExp op' [l, r] | op' == iJoin -> do
+      l' <- rootPExp ctx split l
+      r' <- rootPExp ctx split r
+      when (isRoot r') $ throwError $ SemanticErr pos' "The root is not a child of any clafer"
+      return pexp{_exp = IFunExp op' [l', r']}
+    IFunExp op' [PExp{_exp = IFunExp op'' [l, PExp{_exp = IClaferId{_sident = s}}]}]
+      | op' == iCSet, op'' == iJoin, s == parentIdent, Just ParentRoot <- parentKindOf l, not (isSingle l || alwaysExists l) -> do
+      l' <- rootPExp ctx split l
+      let int n = PExp (Just TInteger) "" noSpan $ IInt n
+      return pexp{_iType = Just TInteger, _exp = IFunExp iIfThenElse [exists l', int 1, int 0]}
+    IFunExp op' [e] | op' == iCSet -> do
+      e' <- rootPExp ctx split e
+      return $ if isRoot e' then pexp{_iType = Just TInteger, _exp = IInt 1} else pexp{_exp = IFunExp op' [e']}
+    IFunExp op' es -> do
+      es' <- mapM (rootPExp ctx split) es
+      when (any isRoot es') $ throwError $ SemanticErr pos' $ rootAsValue op'
+      return $ case (lookup op' comparisons, es') of
+        -- e.g., #this.parent = 1, which is 1 = 1 now; the comparisons of the model stay
+        (Just cmp, [PExp{_exp = IInt m}, PExp{_exp = IInt n}]) | or (zipWith becameInt es es') ->
+          pexp{_iType = Just TBoolean, _exp = constant $ cmp m n}
+        _ -> pexp{_exp = IFunExp op' es'}
+    -- the parent of a set of instances of top-level clafers exists when an instance does
+    IDeclPExp q [] PExp{_exp = IFunExp op' [l, PExp{_exp = IClaferId{_sident = s}}]}
+      | op' == iJoin, s == parentIdent, Just ParentRoot <- parentKindOf l, not (isSingle l || alwaysExists l) -> do
+      l' <- rootPExp ctx split l
+      return $ case q of
+        ILone -> pexp{_iType = Just TBoolean, _exp = constant True}
+        INo -> pexp{_exp = IDeclPExp INo [] l'}
+        _ -> pexp{_exp = IDeclPExp ISome [] l'}
+    IDeclPExp q [] e -> do
+      e' <- rootPExp ctx split e
+      return $ if isRoot e'
+        then pexp{_iType = Just TBoolean, _exp = constant (q /= INo)}
+        else pexp{_exp = IDeclPExp q [] e'}
+    IDeclPExp q ds e -> do
+      ds' <- forM ds $ \d -> do
+        body' <- rootPExp ctx split $ _body d
+        when (isRoot body') $ throwError $ SemanticErr pos' "A variable cannot range over the root, which has no instance"
+        return d{_body = body'}
+      e' <- rootPExp ctx split e
+      return pexp{_exp = IDeclPExp q ds' e'}
+    -- clafer as a value: the union of all clafers, i.e., of the clafers with no super clafer, or
+    -- noclafer in a model without clafers
+    IClaferId{_sident = s} | s == baseClafer -> return $ case topClafers of
+      [] -> pexp{_iType = Just noClaferTClafer, _exp = IClaferId "" noClaferIdent True (GlobalBind noClaferIdent)}
+      -- all the instances of each clafer, a nested one by its path from the top level, e.g., c.d
+      cs -> (foldl1 union' $ map instancesOf cs){_inPos = pos'}
+    _ -> return pexp
+    where
+    toRoot p = p{_iType = Just rootTClafer, _exp = IClaferId "" rootIdent True (GlobalBind rootIdent)}
+    union' l r = PExp ((+++) <$> _iType l <*> _iType r) "" pos' $ IFunExp iUnion [l, r]
+    exists l' = PExp (Just TBoolean) "" noSpan $ IDeclPExp ISome [] l'
+
+  parentKindOf :: PExp -> Maybe ParentKind
+  -- an intersection is in its right operand, e.g., this ** g.f2 of a split constraint, which an
+  -- explicit model keeps: its instances have the parents of the right operand's
+  parentKindOf PExp{_exp = IFunExp op' [_, r]} | op' == iIntersection = parentKindOf r
+  parentKindOf p = case _iType p of
+    Just (TClafer uids@(_:_)) | Just cs <- mapM (findIClafer uidMap) uids, all isRootChild cs -> Just ParentRoot
+    Just (TClafer [uid']) | Just c <- findIClafer uidMap uid', isTopLevel c, _isAbstract c -> Just $ parentKind uid'
+    _ -> Nothing
+
+  -- a concrete top-level clafer that has an instance in every instance of the model
+  alwaysExists :: PExp -> Bool
+  alwaysExists PExp{_exp = IClaferId{_sident = s, _binding = GlobalBind _}}
+    | Just c <- findIClafer uidMap s, isRootChild c, Just (lower, _) <- _card c = lower >= 1
+  alwaysExists _ = False
+
+  claferNames p = case _iType p of
+    Just (TClafer uids) -> unwords $ map (\u -> maybe u _ident $ findIClafer uidMap u) uids
+    _ -> "the expression"
+
+  -- whether the constraint takes the parent of @this@, which the split decides
+  takesParentOfThis :: PExp -> Bool
+  takesParentOfThis PExp{_exp = exp'} = case exp' of
+    IFunExp op' [l, PExp{_exp = IClaferId{_sident = s}}] | op' == iJoin, s == parentIdent, isThis l -> True
+    IFunExp _ es -> any takesParentOfThis es
+    IDeclPExp _ ds e -> any (takesParentOfThis . _body) ds || takesParentOfThis e
+    _ -> False
+
+-- | The parent of the instances of a top-level clafer: the root for a concrete one, and, for an
+--   abstract one, an instance, when its concrete subclafers are nested, the root, when they are
+--   at the top level, or, when they are both, the root for the top-level ones and an instance
+--   for the nested ones
+data ParentKind = ParentReal | ParentRoot | ParentMixed [IClafer] [IClafer]
+
+isRoot :: PExp -> Bool
+isRoot PExp{_exp = IClaferId{_sident = s}} = s == rootIdent
+isRoot _ = False
+
+isThis :: PExp -> Bool
+isThis PExp{_exp = IClaferId{_sident = s}} = s == thisIdent
+isThis _ = False
+
+-- | @this@ or a variable: one instance, whose parent always exists
+isSingle :: PExp -> Bool
+isSingle PExp{_exp = IClaferId{_binding = LocalBind _}} = True
+isSingle p = isThis p
+
+-- | True as @0 < 1@, false as @1 < 0@: the IR has no boolean constants, and Alloy warns that
+--   @0 = 0@ is redundant.
+constant :: Bool -> IExp
+constant b = IFunExp iLt $ if b then [int 0, int 1] else [int 1, int 0]
+  where
+  int n = PExp (Just TInteger) "" noSpan $ IInt n
+
+becameInt :: PExp -> PExp -> Bool
+becameInt PExp{_exp = IInt _} _ = False
+becameInt _ PExp{_exp = IInt _} = True
+becameInt _ _ = False
+
+comparisons :: [(String, Integer -> Integer -> Bool)]
+comparisons = [(iEq, (==)), (iNeq, (/=)), (iLt, (<)), (iGt, (>)), (iLte, (<=)), (iGte, (>=))]
+
+rootAsValue :: String -> String
+rootAsValue op' = "The root has no instance: `root` can be navigated from, e.g., `root.a`, counted (`#root` is 1) and quantified (`some root` holds), but not used in '" ++ op' ++ "'"
diff --git a/src/Language/Clafer/Intermediate/ResolverType.hs b/src/Language/Clafer/Intermediate/ResolverType.hs
--- a/src/Language/Clafer/Intermediate/ResolverType.hs
+++ b/src/Language/Clafer/Intermediate/ResolverType.hs
@@ -20,7 +20,7 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
 -}
-module Language.Clafer.Intermediate.ResolverType (resolveTModule)  where
+module Language.Clafer.Intermediate.ResolverType (resolveTModule, redundantExps)  where
 
 import Language.ClaferT
 import Language.Clafer.Common
@@ -32,8 +32,11 @@
 import Control.Applicative
 import Control.Exception (assert)
 import Control.Lens ((&), (%~), traversed)
+import Control.Lens.Plated (universeOn)
+import Data.Data.Lens (biplate)
+import Control.Monad
 import Control.Monad.Except
-import Control.Monad.List
+import Control.Monad.Trans.List  -- instead of the deprecated Control.Monad.List
 import Control.Monad.Reader
 import Data.Either
 import Data.List
@@ -46,11 +49,14 @@
 newtype TypeAnalysis a = TypeAnalysis (ReaderT TypeInfo (Either ClaferSErr) a)
   deriving (MonadError ClaferSErr, Monad, Functor, MonadReader TypeInfo, Applicative)
 
+instance MonadFail TypeAnalysis where
+  fail = throwError . ClaferErr
+
 -- return the type of a UID but give preference to local declarations in quantified expressions, which shadow global names
 typeOfUid :: MonadTypeAnalysis m => UID -> m IType
-typeOfUid uid = (fromMaybe (TClafer [uid]) . lookup uid) <$> typeDecls
+typeOfUid uid = fromMaybe (TClafer [uid]) . lookup uid <$> typeDecls
 
-class (Functor m, Monad m) => MonadTypeAnalysis m where
+class MonadFail m => MonadTypeAnalysis m where
   -- What "this" refers to
   curThis :: m IClafer
   localCurThis :: IClafer -> m a -> m a
@@ -102,12 +108,12 @@
 runTypeAnalysis :: TypeAnalysis a -> IModule -> Either ClaferSErr a
 runTypeAnalysis (TypeAnalysis tc) imodule = runReaderT tc $ TypeInfo [] (createUidIClaferMap imodule) undefined Nothing
 
-claferWithUid :: (Monad m) => UIDIClaferMap -> String -> m IClafer
+claferWithUid :: MonadFail m => UIDIClaferMap -> String -> m IClafer
 claferWithUid uidIClaferMap' u = case findIClafer uidIClaferMap' u of
   Just c -> return c
   Nothing -> fail $ "ResolverType.claferWithUid: " ++ u ++ " not found!"
 
-parentOf :: (Monad m) => UIDIClaferMap -> UID -> m UID
+parentOf :: MonadFail m => UIDIClaferMap -> UID -> m UID
 parentOf uidIClaferMap' c = case _parentUID <$> findIClafer uidIClaferMap' c of
   Just u -> return u
   Nothing -> fail $ "ResolverType.parentOf: " ++ c ++ " not found!"
@@ -119,13 +125,13 @@
  -    C      // C - child
  -  B : A    // B - parent
  -}
-isIndirectChild :: (Monad m) => UIDIClaferMap -> UID -> UID -> m Bool
+isIndirectChild :: MonadFail m => UIDIClaferMap -> UID -> UID -> m Bool
 isIndirectChild uidIClaferMap' child parent = do
   (_:allSupers) <- hierarchy uidIClaferMap' parent
-  childOfSupers <- mapM ((isChild uidIClaferMap' child)._uid) allSupers
+  childOfSupers <- mapM (isChild uidIClaferMap' child._uid) allSupers
   return $ or childOfSupers
 
-isChild :: (Monad m) => UIDIClaferMap -> UID -> UID -> m Bool
+isChild :: MonadFail m => UIDIClaferMap -> UID -> UID -> m Bool
 isChild uidIClaferMap' child parent =
     case findIClafer uidIClaferMap' child of
         Nothing -> return False
@@ -248,6 +254,11 @@
 resolveTPExp' p@PExp{_exp = IClaferId{_sident = "string"}} = runListT $ runExceptT $ return $ p `withType` TString
 resolveTPExp' p@PExp{_exp = IClaferId{_sident = "double"}} = runListT $ runExceptT $ return $ p `withType` TDouble
 resolveTPExp' p@PExp{_exp = IClaferId{_sident = "real"}} = runListT $ runExceptT $ return $ p `withType` TReal
+resolveTPExp' p@PExp{_exp = IClaferId{_sident = "decimal"}} = runListT $ runExceptT $ return $ p `withType` TDecimal
+-- noclafer, the empty set, has no reference to dereference
+resolveTPExp' p@PExp{_exp = IClaferId{_sident = "noclafer"}} = runListT $ runExceptT $ return $ p `withType` noClaferTClafer
+-- clafer, the union of all clafers, which ResolverRoot writes out
+resolveTPExp' p@PExp{_exp = IClaferId{_sident = "clafer"}} = runListT $ runExceptT $ return $ p `withType` claferTClafer
 resolveTPExp' p@PExp{_inPos, _exp = IClaferId{_sident="this"}} =
   runListT $ runExceptT $ do
     sident' <- _uid <$> curThis
@@ -298,6 +309,7 @@
   resolveTExp :: IExp -> TypeAnalysis [Either ClaferSErr (IType, IExp)]
   resolveTExp e@(IInt _)    = runListT $ runExceptT $ return (TInteger, e)
   resolveTExp e@(IDouble _) = runListT $ runExceptT $ return (TDouble, e)
+  resolveTExp e@(IDecimal _) = runListT $ runExceptT $ return (TDecimal, e)
   resolveTExp e@(IReal _) = runListT $ runExceptT $ return (TReal, e)
   resolveTExp e@(IStr _)    = runListT $ runExceptT $ return (TString, e)
 
@@ -311,32 +323,63 @@
               throwError $ SemanticErr _inPos ("Function '" ++ _op ++ "' cannot be performed on " ++ _op ++ " '" ++ showType arg' ++ "'")
       let result
             | _op == iNot = test (isTBoolean t) >> return TBoolean
+            | _op `elem` ltlUnOps = test (isTBoolean t) >> return TBoolean
             | _op == iCSet = return TInteger
-            | _op == iSumSet = test (isTInteger t) >> return TInteger
+            | _op == iInitValue = return t
+            -- a sum of decimals is a decimal; a product of decimals is not supported
+            | _op == iSumSet = test (isTInteger t || isTDecimal t) >> return (if isTDecimal t then TDecimal else TInteger)
             | _op == iProdSet = test (isTInteger t) >> return TInteger
             | _op `elem` [iMin, iMinimum, iMaximum, iMinimize, iMaximize] = test (numeric t) >> return t
-            | otherwise = assert False $ error $ "Unknown op '" ++ _op ++ "'"
+            | otherwise = assert False $ fail $ "Unknown op '" ++ _op ++ "'"
       result' <- result
-      return (result', e{_exps = [arg']})
+      return (result', splitUnion result' e{_exps = [arg']})
+    where
+    -- The generators sum (multiply) the references of each instance, so
+    -- sum (a ++ b) becomes sum a + sum b, and product (a ++ b) product a * product b.
+    -- A constant in the union is added (multiplied) as is.
+    splitUnion t' e'@IFunExp{_op = op', _exps = [PExp{_exp = IFunExp "++" [a, b]}]}
+      | op' `elem` [iSumSet, iProdSet] = IFunExp (if op' == iSumSet then iPlus else iMul) [part a, part b]
+      | otherwise = e'
+      where
+      part a'@PExp{_exp = IInt _} = a'
+      part a'@PExp{_exp = IDecimal _} = a'
+      part a'@(PExp _ _ pos' _) = PExp (Just t') "" pos' (splitUnion t' $ IFunExp op' [a'])
+    splitUnion _ e' = e'
 
+  -- The unions of the fewest unrelated types (with distinct topmost supers) come
+  -- first, so that a reference is dereferenced when that makes the operands
+  -- alike: in `others ++ p1`, with `others -> Person` and `p1 : Person`,
+  -- others.dref ++ p1 (Person) is preferred over others ++ p1 (others or
+  -- Person), and in `BobPicks ++ 3`, BobPicks.dref ++ 3 (integer) over
+  -- BobPicks ++ 3 (BobPicks or integer). Among equally good unions, the
+  -- original order (without dereferencing) is kept. Unions of booleans come last.
   resolveTExp e@IFunExp {_op = "++", _exps = [arg1, arg2]} = do
-      -- arg1s' <- resolveTPExp arg1
-      -- arg2s' <- resolveTPExp arg2
-      -- let union' a b = typeOf a +++ typeOf b
-      -- return [ return (union' arg1' arg2', e{_exps = [arg1', arg2']})
-      --        | (arg1', arg2') <- sortBy (comparing $ length . unionType . uncurry union') $ liftM2 (,) arg1s' arg2s'
-      --        , not (isTBoolean $ typeOf arg1') && not (isTBoolean $ typeOf arg2') ]
-      runListT $ runExceptT $ do
+      uidIClaferMap' <- asks iUIDIClaferMap
+      unions <- runListT $ runExceptT $ do
         arg1' <- lift $ ListT $ resolveTPExp arg1
         arg2' <- lift $ ListT $ resolveTPExp arg2
         let t1 = typeOf arg1'
         let t2 = typeOf arg2'
         return (t1 +++ t2, e{_exps = [arg1', arg2']})
+      return $ sortOn (either (const (True, maxBound)) (rank uidIClaferMap' . fst)) unions
+    where
+      rank uidIClaferMap' t = (isTBoolean t, length $ nub $ map (topmost uidIClaferMap') $ unionType t)
+      topmost uidIClaferMap' u = maybe u (last . mapHierarchy _uid getSuper uidIClaferMap') $ findIClafer uidIClaferMap' u
 
 
+  -- The alternatives which type check only through the type "clafer" come last.
+  -- For example, under the reference `services -> Service` of Machine,
+  -- `this.machine = parent` is this.dref.machine.dref = this.parent; the
+  -- alternative this.dref.machine = this.dref.parent, the parent of the abstract
+  -- Service of type "clafer", also type checks.
+  -- A comparison, an intersection or a difference of two navigations to reference clafers is
+  -- of their targets, e.g.,
+  -- `this.a = parent.b.a` is this.a.dref = parent.b.a.dref: the instances of `a` under different
+  -- parents are never equal (#87). An operand that is `this`, a variable or ends with `dref`
+  -- is compared as it is.
   resolveTExp e@IFunExp {_op, _exps = [arg1, arg2]} = do
     uidIClaferMap' <- asks iUIDIClaferMap
-    runListT $ runExceptT $ do
+    sortOn (either (const (maxBound, maxBound)) (\(_, e') -> (viaClafer e', comparesReferences uidIClaferMap' e'))) <$> (runListT $ runExceptT $ do
       arg1' <- lift $ ListT $ resolveTPExp arg1
       arg2' <- lift $ ListT $ resolveTPExp arg2
       let t1 = typeOf arg1'
@@ -349,28 +392,46 @@
                             then throwError $ SemanticErr _inPos ("Function '" ++ _op ++ "' cannot be performed on\n" ++ showType arg1' ++ "\n" ++ _op ++ "\n" ++ showType arg2')
                             else return it'
                 Nothing  -> throwError $ SemanticErr _inPos ("Function '" ++ _op ++ "' cannot be performed on\n" ++ showType arg1' ++ "\n" ++ _op ++ "\n" ++ showType arg2')
-      let testNotSame e1 e2 =
-            when (e1 `sameAs` e2) $
-              throwError $ SemanticErr _inPos ("Function '" ++ _op ++ "' is redundant because the two subexpressions are always equivalent")
       let test c =
             unless c $
               throwError $ SemanticErr _inPos ("Function '" ++ _op ++ "' cannot be performed on\n" ++ showType arg1' ++ "\n" ++ _op ++ "\n" ++ showType arg2')
       let result
             | _op `elem` logBinOps = test (isTBoolean t1 && isTBoolean t2) >> return TBoolean
+            | _op `elem` ltlBinOps = test (isTBoolean t1 && isTBoolean t2) >> return TBoolean
             | _op `elem` [iLt, iGt, iLte, iGte] = test (numeric t1 && numeric t2) >> return TBoolean
-            | _op `elem` [iEq, iNeq] = testNotSame arg1' arg2' >> testIntersect t1 t2 >> return TBoolean
-            | _op == iDifference = testNotSame arg1' arg2' >> testIntersect t1 t2 >> return t1
-            | _op == iIntersection = testNotSame arg1' arg2' >> testIntersect t1 t2
+            | _op `elem` [iEq, iNeq] = testIntersect t1 t2 >> return TBoolean
+            | _op == iDifference = testIntersect t1 t2 >> return t1
+            | _op == iIntersection = testIntersect t1 t2
             | _op `elem` [iDomain, iRange] = testIntersect t1 t2
             | _op `elem` relSetBinOps = testIntersect t1 t2 >> return TBoolean
-            | _op `elem` [iSub, iMul, iDiv, iRem] = test (numeric t1 && numeric t2) >> return (coerce t1 t2)
+            | _op `elem` [iSub, iMul, iDiv, iRem] = test (allNumeric t1 && allNumeric t2) >> return (coerce t1 t2)
             | _op == iPlus =
                 (test (isTString t1 && isTString t2) >> return TString) -- Case 1: String concatenation
                 `catchError`
-                const (test (numeric t1 && numeric t2) >> return (coerce t1 t2)) -- Case 2: Addition
-            | otherwise = error $ "ResolverType: Unknown op: " ++ show e
+                const (test (allNumeric t1 && allNumeric t2) >> return (coerce t1 t2)) -- Case 2: Addition
+            | otherwise = fail $ "ResolverType: Unknown op: " ++ show e
       result' <- result
-      return (result', e{_exps = [arg1', arg2']})
+      return (result', e{_exps = [arg1', arg2']}))
+    where
+      -- the number of operands of type "clafer"
+      viaClafer :: IExp -> Int
+      viaClafer IFunExp{_exps = exps'} = length [ () | PExp{_iType = Just t} <- exps', "clafer" `elem` unionType t ]
+      viaClafer _ = 0
+      -- whether a comparison, an intersection or a difference is of the instances of reference
+      -- clafers on both sides
+      comparesReferences :: UIDIClaferMap -> IExp -> Int
+      comparesReferences uidIClaferMap' IFunExp{_op = op', _exps = [e1, e2]}
+        | op' `elem` [iEq, iNeq, iIn, iNin, iIntersection, iDifference], all (isReferenceNav uidIClaferMap') [e1, e2] = 1
+      comparesReferences _ _ = 0
+      isReferenceNav uidIClaferMap' pexp = case lastName pexp of
+        Just uid' -> maybe False (any (not . null) . mapHierarchy getReference getSuper uidIClaferMap') $ findIClafer uidIClaferMap' uid'
+        Nothing -> False
+      lastName PExp{_exp = IFunExp op' [_, r]} | op' == iJoin = lastName r
+      lastName PExp{_exp = IClaferId{_sident = s, _binding = b}}
+        | s `notElem` specialNames, not (isLocalBind b) = Just s
+      lastName _ = Nothing
+      isLocalBind (LocalBind _) = True
+      isLocalBind _ = False
 
   resolveTExp e@(IFunExp "ifthenelse" [arg1, arg2, arg3]) = do
     uidIClaferMap' <- asks iUIDIClaferMap
@@ -423,15 +484,15 @@
             Just t' -> if  isTBoolean t'
                        then throwError $ SemanticErr _inPos "The type of declaration of a quantified expression must not be 'TBoolean'"
                        else return $ d{_body = body'}
-  resolveTExp e = error $ "Unknown iexp: " ++ show e
+  resolveTExp e = fail $ "Unknown iexp: " ++ show e
 
 -- Adds "dref"s at the end, effectively dereferencing Clafers when needed.
 addDref :: PExp -> ExceptT ClaferSErr (ListT TypeAnalysis) PExp
 addDref pexp =
   do
     localCurPath (typeOf pexp) $ do
-      deref <- (ExceptT $ ListT $ resolveTPExp' $ newPExp $ IClaferId "" "dref" False Nothing) `catchError` const (lift mzero)
-      let result = (newPExp $ IFunExp "." [pexp, deref]) `withType` typeOf deref
+      deref <- ExceptT (ListT $ resolveTPExp' $ newPExp $ IClaferId "" "dref" False NoBind) `catchError` const (lift mzero)
+      let result = newPExp (IFunExp "." [pexp, deref]) `withType` typeOf deref
       return result <++> addDref result
   where
   newPExp = PExp Nothing "" $ _inPos pexp
@@ -468,11 +529,16 @@
 liftList :: Monad m => [a] -> ListT m a
 liftList = ListT . return
 
-comparing :: Ord b => (a -> b) -> a -> a -> Ordering
-comparing f a b = f a `compare` f b
-
 syntaxOf :: PExp -> String
 syntaxOf = printTree . sugarExp
+
+-- | The comparisons, differences and intersections of an expression with itself, e.g., @x = x@:
+-- correct, but probably not what was meant, so the compiler warns about them
+redundantExps :: IModule -> [PExp]
+redundantExps imodule =
+  [ p | p@PExp{_exp = IFunExp fun [e1, e2]} <- universeOn biplate imodule
+      , fun `elem` [iEq, iNeq, iDifference, iIntersection]
+      , e1 `sameAs` e2 ]
 
 -- Returns true iff the left and right expressions are syntactically identical
 sameAs :: PExp -> PExp -> Bool
diff --git a/src/Language/Clafer/Intermediate/ScopeAnalysis.hs b/src/Language/Clafer/Intermediate/ScopeAnalysis.hs
--- a/src/Language/Clafer/Intermediate/ScopeAnalysis.hs
+++ b/src/Language/Clafer/Intermediate/ScopeAnalysis.hs
@@ -21,11 +21,59 @@
 -}
 module Language.Clafer.Intermediate.ScopeAnalysis where
 
+import Control.Lens (universeOn)
+import Data.Data.Lens (biplate)
+import Data.Maybe
+import qualified Data.Map as Map
+import qualified Data.Set as Set
+
 import Language.Clafer.ClaferArgs
+import Language.Clafer.Common
 import Language.Clafer.Intermediate.Intclafer
 import Language.Clafer.Intermediate.SimpleScopeAnalyzer
 
 -- | Return an appropriate scope analysis for a given strategy
 getScopeStrategy :: ScopeStrategy -> IModule -> [(String, Integer)]
-getScopeStrategy Simple = simpleScopeAnalysis
-getScopeStrategy _      = const []
+getScopeStrategy strategy iModule = withEmptyAbstracts iModule $ case strategy of
+    Simple -> simpleScopeAnalysis iModule
+    _      -> []
+
+-- | An abstract clafer that no concrete clafer inherits from, directly or through other abstract
+-- clafers, has no instances: its scope is 0. Alloy gives an abstract sig without subsigs atoms
+-- of its own otherwise, and translates all the constraints of the clafer for them.
+withEmptyAbstracts :: IModule -> [(UID, Integer)] -> [(UID, Integer)]
+withEmptyAbstracts iModule scopes =
+    Map.toList $ Map.union (Map.fromSet (const 0) $ emptyAbstracts iModule) (Map.fromList scopes)
+
+-- | The abstract clafers that no concrete clafer inherits from, directly or through other abstract
+-- clafers, and the clafers nested in them: they have no instances, whatever their scopes.
+emptyAbstracts :: IModule -> Set.Set UID
+emptyAbstracts iModule =
+    Set.fromList [ _uid c' | c <- clafers, _isAbstract c, not $ Set.member (_uid c) inherited, c' <- c : universeOn biplate c ]
+    where
+    uidClaferMap' = createUidIClaferMap iModule
+    clafers = universeOn biplate iModule :: [IClafer]
+    -- the supers of the concrete clafers, all the way up their chains of inheritance
+    inherited = Set.fromList [ _uid super' | c <- clafers, not $ _isAbstract c, super' <- drop 1 $ findHierarchy getSuper uidClaferMap' c ]
+
+-- | The scope above which a scope is large
+largeScope :: Integer
+largeScope = 100
+
+-- | The references with an unbounded multiplicity to a clafer (`refs -> A *`) whose scopes are large,
+-- with their targets. Such a reference may point to every instance of its target, so its scope is
+-- the target's scope per parent; an upper bound in its multiplicity makes it smaller.
+largeReferenceScopes :: IModule -> [(UID, Integer)] -> [(IClafer, Integer, IClafer, Integer)]
+largeReferenceScopes iModule scopes =
+    [ (c, scopeOf c, target, scopeOf target)
+    | c <- universeOn biplate iModule
+    , (snd <$> _card c) == Just (-1)
+    , [ref'] <- [getReference c]
+    , not $ isPrimitive ref'
+    , Just target <- [findIClafer uidClaferMap' ref']
+    , scopeOf c > largeScope
+    ]
+    where
+    uidClaferMap' = createUidIClaferMap iModule
+    -- a clafer without an inferred scope has the global scope, 1 by default
+    scopeOf c' = fromMaybe 1 $ lookup (_uid c') scopes
diff --git a/src/Language/Clafer/Intermediate/SimpleScopeAnalyzer.hs b/src/Language/Clafer/Intermediate/SimpleScopeAnalyzer.hs
--- a/src/Language/Clafer/Intermediate/SimpleScopeAnalyzer.hs
+++ b/src/Language/Clafer/Intermediate/SimpleScopeAnalyzer.hs
@@ -61,9 +61,11 @@
     constraints = concatMap findConstraints decls'
 
     lowerOrUpperFixedCard analysis' clafer =
-        maximum [cardLb, cardUb, lowFromConstraints, oneForStar, targetScopeForStar ]
+        maximum [cardLb, cardUb, lowFromConstraints, oneForStar, targetScopeForStar, lowFromGroupCard ]
         where
-        Just (cardLb, cardUb) = _card clafer
+        (cardLb, cardUb) = case _card clafer of
+            (Just c) -> c
+            Nothing  -> (1, 1)
         oneForStar = if (cardLb == 0 && cardUb == -1) then 1 else 0
         targetScopeForStar = if ((isJust $ _reference clafer) && cardUb == -1)
             then case getReference clafer of
@@ -71,6 +73,12 @@
                 _      -> 0
             else 0
         lowFromConstraints = Map.findWithDefault 0 (_uid clafer) constraintAnalysis
+        -- The group cardinality n..m of the parent requires at least n children,
+        -- possibly all instances of this clafer.
+        lowFromGroupCard = case _gcard =<< findIClafer uidClaferMap' =<< Map.lookup (_uid clafer) parentMap of
+            Just (IGCard _ (groupLb, _)) | cardUb == -1 -> groupLb
+                                         | otherwise    -> min groupLb cardUb
+            Nothing -> 0
 
     analyzeComponent analysis' component =
         case flattenSCC component of
@@ -103,10 +111,15 @@
         findOrError message m key = Map.findWithDefault (error $ key ++ message) key m
 
 analyzeSupers :: UIDIClaferMap -> [IClafer] -> Map String Integer -> IElement -> Map String Integer
-analyzeSupers uidClaferMap' clafers analysis (IEClafer clafer) =
-    foldl (analyzeSupers uidClaferMap' clafers) analysis' (_elements clafer)
+analyzeSupers uidClaferMap' clafers analysis (IEClafer clafer)
+    -- a clafer without instances, e.g., an abstract clafer that no concrete clafer extends,
+    -- adds none to its super, and neither do its children
+    | cardUb == 0 = analysis
+    | otherwise   = foldl (analyzeSupers uidClaferMap' clafers) analysis' (_elements clafer)
     where
-    (Just (cardLb, cardUb)) = _card clafer
+    (cardLb, cardUb) = case _card clafer of
+        (Just c) -> c
+        Nothing  -> (1, 1)
     lowerOrFixedUpperBound = maximum [1, cardLb, cardUb ]
     analysis' = if (isJust $ _reference clafer)
                 then analysis
@@ -121,7 +134,9 @@
 analyzeRefs uidClaferMap' clafers analysis (IEClafer clafer) =
     foldl (analyzeRefs uidClaferMap' clafers) analysis' (_elements clafer)
     where
-    (Just (cardLb, cardUb)) = _card clafer
+    (cardLb, cardUb) = case _card clafer of
+        (Just c) -> c
+        Nothing  -> (1, 1)
     lowerOrFixedUpperBound = maximum [1, cardLb, cardUb]
     analysis' = if (isJust $ _reference clafer)
                 then case (directSuper uidClaferMap' clafer) of
@@ -227,7 +242,7 @@
 
 dependency :: UIDIClaferMap -> IClafer -> [(String, String)]
 dependency uidClaferMap' clafer =
-    selfDependency : (maybeToList superDependency ++ childDependencies)
+    selfDependency : (maybeToList superDependency ++ childDependencies ++ targetDependencies)
     where
      -- This is to make the "stronglyConnComp" from Data.Graph play nice. Otherwise,
      -- clafers with no dependencies will not appear in the result.
@@ -241,6 +256,11 @@
                 return (_uid super', _uid clafer)
     -- Need to analyze clafer before its children
     childDependencies = [(_uid child, _uid clafer) | child <- childClafers clafer]
+    -- Need to analyze the target of a reference with an unbounded cardinality before
+    -- the reference, whose scope uses the target's (targetScopeForStar)
+    targetDependencies
+        | (snd <$> _card clafer) /= Just (-1) = []
+        | otherwise = [(_uid clafer, _uid target) | [ref'] <- [getReference clafer], Just target <- [findIClafer uidClaferMap' ref']]
 
 
 analyzeHierarchy :: UIDIClaferMap -> [IClafer] -> (Map String [String], Map String String)
diff --git a/src/Language/Clafer/Intermediate/StringAnalyzer.hs b/src/Language/Clafer/Intermediate/StringAnalyzer.hs
--- a/src/Language/Clafer/Intermediate/StringAnalyzer.hs
+++ b/src/Language/Clafer/Intermediate/StringAnalyzer.hs
@@ -23,6 +23,7 @@
 module Language.Clafer.Intermediate.StringAnalyzer where
 
 import Control.Applicative
+import Control.Monad
 import Control.Monad.State
 import Data.Tuple
 import qualified Data.Map as Map
@@ -43,14 +44,14 @@
 
 
 astrClafer :: MonadState (Map.Map String Int) m => IClafer -> m IClafer
-astrClafer (IClafer s isAbstract' gcrd' ident' uid' puid' super' reference' crd' gCard elements') = do
+astrClafer (IClafer s mods gcrd' ident' uid' puid' super' reference' crd' gCard elements') = do
     reference'' <- astrReference reference'
     elements'' <- astrElement `mapM` elements'
-    return $ IClafer s isAbstract' gcrd' ident' uid' puid' super' reference'' crd' gCard elements''
+    return $ IClafer s mods gcrd' ident' uid' puid' super' reference'' crd' gCard elements''
 
 astrReference :: MonadState (Map.Map String Int) m => Maybe IReference -> m (Maybe IReference)
 astrReference Nothing = return Nothing
-astrReference (Just (IReference isSet' ref')) = Just <$> IReference isSet' `liftM` astrPExp ref'
+astrReference (Just (IReference isSet' mod' ref')) = Just <$> IReference isSet' mod' `liftM` astrPExp ref'
 
 -- astrs single subclafer
 astrElement :: MonadState (Map.Map String Int) m => IElement -> m IElement
diff --git a/src/Language/Clafer/Intermediate/Tracing.hs b/src/Language/Clafer/Intermediate/Tracing.hs
--- a/src/Language/Clafer/Intermediate/Tracing.hs
+++ b/src/Language/Clafer/Intermediate/Tracing.hs
@@ -81,7 +81,8 @@
     ElementDecl _ e -> traverseElement e
 
 traverseClafer :: Clafer -> [Ast]
-traverseClafer x@(Clafer _ a b _ d r e f g) = AstClafer x : (traverseAbstract a ++ traverseGCard b ++ traverseSuper d ++ traverseReference r ++ traverseCard e ++ traverseInit f ++ traverseElements g)
+traverseClafer x@(Clafer _ a _ gcard' _ super' ref' card' init' _ g) =
+  AstClafer x : (traverseAbstract a ++ traverseGCard gcard' ++ traverseSuper super' ++ traverseReference ref' ++ traverseCard card' ++ traverseInit init' ++ traverseElements g)
 
 traverseConstraint :: Constraint -> [Ast]
 traverseConstraint x@(Constraint _ e) = AstConstraint x : concatMap traverseExp e
@@ -178,17 +179,36 @@
 traverseExp x =
   AstExp x :
     case x of
+    TransitionExp _ e1 _ e2 -> traverseExp e1 ++ traverseExp e2
     EDeclAllDisj _ d e -> traverseDecl d ++ traverseExp e
     EDeclAll _ d e -> traverseDecl d ++ traverseExp e
     EDeclQuantDisj _ q d e -> traverseQuant q ++ traverseDecl d ++ traverseExp e
     EDeclQuant _ q d e -> traverseQuant q ++ traverseDecl d ++ traverseExp e
-    EGMax _ e -> traverseExp e
-    EGMin _ e -> traverseExp e
+    EImpliesElse _ e1 e2 e3 -> traverseExp e1 ++ traverseExp e2 ++ traverseExp e3
+    LetExp _ _ e -> traverseExp e
+    TmpPatNever _ e _ -> traverseExp e
+    TmpPatSometime _ e _ -> traverseExp e
+    TmpPatLessOrOnce _ e _ -> traverseExp e
+    TmpPatAlways _ e _ -> traverseExp e
+    TmpPatPrecede _ e1 e2 _ -> traverseExp e1 ++ traverseExp e2
+    TmpPatFollow _ e1 e2 _ -> traverseExp e1 ++ traverseExp e2
+    TmpInitially _ e -> traverseExp e
+    TmpFinally _ e -> traverseExp e
     EIff _ e1 e2 -> traverseExp e1 ++ traverseExp e2
     EImplies _ e1 e2 -> traverseExp e1 ++ traverseExp e2
     EOr _ e1 e2 -> traverseExp e1 ++ traverseExp e2
     EXor _ e1 e2 -> traverseExp e1 ++ traverseExp e2
     EAnd _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    LtlU _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    TmpUntil _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    LtlW _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    TmpWUntil _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    LtlF _ e -> traverseExp e
+    TmpEventually _ e -> traverseExp e
+    LtlG _ e -> traverseExp e
+    TmpGlobally _ e -> traverseExp e
+    LtlX _ e -> traverseExp e
+    TmpNext _ e -> traverseExp e
     ENeg _ e -> traverseExp e
     ELt _ e1 e2 -> traverseExp e1 ++ traverseExp e2
     EGt _ e1 e2 -> traverseExp e1 ++ traverseExp e2
@@ -204,24 +224,25 @@
     EMul _ e1 e2 -> traverseExp e1 ++ traverseExp e2
     EDiv _ e1 e2 -> traverseExp e1 ++ traverseExp e2
     ERem _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EGMax _ e -> traverseExp e
+    EGMin _ e -> traverseExp e
     ESum _ e -> traverseExp e
     EProd _ e -> traverseExp e
     ECard _ e -> traverseExp e
     EMinExp _ e -> traverseExp e
-    EImpliesElse _ e1 e2 e3 -> traverseExp e1 ++ traverseExp e2 ++ traverseExp e3
-    EInt _ _ -> []
-    EDouble _ _ -> []
-    EReal _ _ -> []
-    EStr _ _ -> []
+    EDomain _ s1 s2 -> traverseExp s1 ++ traverseExp s2
+    ERange _ s1 s2 -> traverseExp s1 ++ traverseExp s2
     EUnion _ s1 s2 -> traverseExp s1 ++ traverseExp s2
     EUnionCom _ s1 s2 -> traverseExp s1 ++ traverseExp s2
     EDifference _ s1 s2 -> traverseExp s1 ++ traverseExp s2
     EIntersection _ s1 s2 -> traverseExp s1 ++ traverseExp s2
     EIntersectionDeprecated _ s1 s2 -> traverseExp s1 ++ traverseExp s2
-    EDomain _ s1 s2 -> traverseExp s1 ++ traverseExp s2
-    ERange _ s1 s2 -> traverseExp s1 ++ traverseExp s2
     EJoin _ s1 s2 -> traverseExp s1 ++ traverseExp s2
     ClaferId _ n -> traverseName n
+    EInt _ _ -> []
+    EDouble _ _ -> []
+    EReal _ _ -> []
+    EStr _ _ -> []
 
 traverseDecl :: Decl -> [Ast]
 traverseDecl x@(Decl _ l s) =
diff --git a/src/Language/Clafer/Intermediate/TypeSystem.hs b/src/Language/Clafer/Intermediate/TypeSystem.hs
--- a/src/Language/Clafer/Intermediate/TypeSystem.hs
+++ b/src/Language/Clafer/Intermediate/TypeSystem.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE NamedFieldPuns #-}
 {-
  Copyright (C) 2015-2017 Michal Antkiewicz <http://gsd.uwaterloo.ca>
 
@@ -57,7 +56,7 @@
 -}
 
 {- $setup
->>> :m + Control.Monad.List
+>>> :m + Control.Monad.Trans.Maybe
 
 TClafer
 >>> let tClaferPerson = TClafer [ "Person" ]
@@ -98,20 +97,39 @@
 claferTClafer :: IType
 claferTClafer = TClafer ["clafer"]
 
+-- | The type of @noclafer@, the empty set: a subtype of every clafer type, so a union with it
+-- | and an @if@ with it as a branch have the type of the other operand
+noClaferTClafer :: IType
+noClaferTClafer = TClafer ["noclafer"]
+
 numeric :: IType     -> Bool
 numeric TInteger     = True
+numeric TDecimal     = True
 numeric TReal        = True
 numeric TDouble      = True
 numeric (TMap _ ta') = numeric ta'
 numeric (TUnion un') = any numeric un'
 numeric _            = False
 
+-- | Whether arithmetic can be performed on the type: unlike 'numeric', all
+-- the types of a union must be numeric, so that 'coerce' can be applied.
+allNumeric :: IType     -> Bool
+allNumeric (TMap _ ta') = allNumeric ta'
+allNumeric (TUnion un') = all allNumeric un'
+allNumeric t            = numeric t
+
 isTInteger :: IType    -> Bool
 isTInteger TInteger     = True
 isTInteger (TMap _ ta') = isTInteger ta'
 isTInteger (TUnion un') = any isTInteger un'
 isTInteger _            = False
 
+isTDecimal :: IType    -> Bool
+isTDecimal TDecimal     = True
+isTDecimal (TMap _ ta') = isTDecimal ta'
+isTDecimal (TUnion un') = any isTDecimal un'
+isTDecimal _            = False
+
 isTString :: IType    -> Bool
 isTString TString      = True
 isTString (TMap _ ta') = isTString ta'
@@ -140,6 +158,7 @@
 getTClaferByUID    uidIClaferMap'   uid' = case uid' of
   "root"   -> Just rootTClafer
   "clafer" -> Just claferTClafer
+  "noclafer" -> Just noClaferTClafer
   _        -> findIClafer uidIClaferMap' uid' <&> getTClafer
 
 -- | Get TClafer for a given Clafer by its UID
@@ -147,6 +166,7 @@
 getTClaferFromIExp :: UIDIClaferMap -> IExp -> Maybe IType
 getTClaferFromIExp    uidIClaferMap'   (IClaferId _ uid' _ _) = getTClaferByUID uidIClaferMap' uid'
 getTClaferFromIExp    _                (IInt _)               = Just TInteger
+getTClaferFromIExp    _                (IDecimal _)           = Just TDecimal
 getTClaferFromIExp    _                (IReal _)              = Just TReal
 getTClaferFromIExp    _                (IDouble _)            = Just TDouble
 getTClaferFromIExp    _                (IStr _)               = Just TString
@@ -166,15 +186,16 @@
 getDrefTMapByUID    uidIClaferMap'   uid' = case uid' of
   "root"   -> Nothing
   "clafer" -> Nothing
+  "noclafer" -> Nothing
   _        -> findIClafer uidIClaferMap' uid' >>= getDrefTMap
 
 
-hierarchy :: (Monad m) => UIDIClaferMap -> UID -> m [IClafer]
+hierarchy :: MonadFail m => UIDIClaferMap -> UID -> m [IClafer]
 hierarchy uidIClaferMap' uid' = case findIClafer uidIClaferMap' uid' of
       Nothing -> fail $ "TypeSystem.hierarchy: clafer " ++ uid' ++ "not found!"
       Just clafer -> return $ findHierarchy getSuper uidIClaferMap' clafer
 
-hierarchyMap :: (Monad m) => UIDIClaferMap -> (IClafer -> a) -> UID -> m [a]
+hierarchyMap :: MonadFail m => UIDIClaferMap -> (IClafer -> a) -> UID -> m [a]
 hierarchyMap uidIClaferMap' f c = case findIClafer uidIClaferMap' c of
       Nothing -> fail $ "TypeSystem.hierarchyMap: clafer " ++ c ++ "not found!"
       Just clafer -> return $ mapHierarchy f getSuper uidIClaferMap' clafer
@@ -187,6 +208,7 @@
 unionType :: IType -> [String]
 unionType TString  = [stringType]
 unionType TReal    = [realType]
+unionType TDecimal = [decimalType]
 unionType TDouble  = [doubleType]
 unionType TInteger = [integerType]
 unionType TBoolean = [booleanType]
@@ -200,10 +222,12 @@
         ["string"]  -> Just TString
         ["integer"] -> Just TInteger
         ["int"]     -> Just TInteger
+        ["decimal"] -> Just TDecimal
         ["double"]  -> Just TDouble
         ["real"]    -> Just TReal
         ["root"]    -> Just rootTClafer
         ["clafer"]  -> Just claferTClafer
+        ["noclafer"] -> Just noClaferTClafer
         []          -> Nothing
         u'          -> Just $ TClafer u'
 
@@ -218,6 +242,10 @@
 >>> TString +++ TInteger
 TUnion {_un = [TString,TInteger]}
 
+Integers are decimals, e.g., in `1, 2.5`.
+>>> TInteger +++ TDecimal
+TDecimal
+
 >>> TString +++ TUnion [TInteger]
 TUnion {_un = [TString,TInteger]}
 
@@ -242,17 +270,32 @@
 
 >>> TClafer {_hi = ["A", "X"]} +++ (TClafer {_hi = ["B", "X"]} +++ TClafer {_hi = ["C", "X"]})
 TClafer {_hi = ["A","X","B","C"]}
+
+A dereferenced reference in a union with a value, e.g., `BobPicks ++ 3`, is a union of the targets.
+>>> tDrefMapEmplID +++ TInteger
+TInteger
+
+>>> TInteger +++ tDrefMapEmplID
+TInteger
 -}
 (+++) :: IType -> IType -> IType
+-- noclafer, the empty set, adds nothing
+TClafer ["noclafer"] +++ t2         = t2
+t1              +++ TClafer ["noclafer"] = t1
 TBoolean        +++ TBoolean        = TBoolean
 TString         +++ TString         = TString
 TReal           +++ TReal           = TReal
+TDecimal        +++ TDecimal        = TDecimal
+TDecimal        +++ TInteger        = TDecimal
+TInteger        +++ TDecimal        = TDecimal
 TDouble         +++ TDouble         = TDouble
 TInteger        +++ TInteger        = TInteger
 t1@(TClafer u1) +++ t2@(TClafer u2) = if t1 == t2
                                       then t1
                                       else TClafer $ nub $ u1 ++ u2  -- should be TUnion [t1,t2]
 (TMap so1 ta1)  +++ (TMap so2 ta2)  = TMap (so1 +++ so2) (ta1 +++ ta2)
+(TMap _ ta1)    +++ t2              = ta1 +++ t2
+t1              +++ (TMap _ ta2)    = t1 +++ ta2
 (TUnion un1)    +++ (TUnion un2)    = collapseUnion (TUnion $ nub $ un1 ++ un2)
 (TUnion un1)    +++ t2              = collapseUnion (TUnion $ nub $ un1 ++ [t2])
 t1              +++ (TUnion un2)    = collapseUnion (TUnion $ nub $ t1:un2)
@@ -269,31 +312,39 @@
 -- t1 +++ t2 = fromJust $ fromUnionType $ unionType t1 ++ unionType t2
 
 {- | Intersection of two types.
->>> runListT $ intersection undefined TString TString
-[Just TString]
+>>> runMaybeT $ intersection undefined TString TString
+Just (Just TString)
 
->>> runListT $ intersection undefined TInteger TString
-[Nothing]
+>>> runMaybeT $ intersection undefined TInteger TString
+Just Nothing
 
->>> runListT $ intersection undefined TInteger TReal
-[Just TReal]
+>>> runMaybeT $ intersection undefined TInteger TReal
+Just (Just TReal)
 
->>> runListT $ intersection undefined tDrefMapDOB TInteger
-[Just TInteger]
+>>> runMaybeT $ intersection undefined tDrefMapDOB TInteger
+Just (Just TInteger)
 
 Cannot assign a TReal to a map to TInteger
->>> runListT $ intersection undefined tDrefMapDOB TReal
-[Nothing]
+>>> runMaybeT $ intersection undefined tDrefMapDOB TReal
+Just Nothing
 
 Cannot assign a TReal to a map to TInteger
->>> runListT $ intersection undefined TReal tDrefMapDOB
-[Nothing]
+>>> runMaybeT $ intersection undefined TReal tDrefMapDOB
+Just Nothing
 
-runListT $ intersection undefined TClafer {_hi = ["A","X","B","C"]} TClafer {_hi = ["X"]}
-[ Just TClafer {_hi = ["X"]]
+Integers are decimals.
+>>> runMaybeT $ intersection undefined TInteger TDecimal
+Just (Just TDecimal)
+
+A decimal and a double have only real in common: 0.1 is not a double.
+>>> runMaybeT $ intersection undefined TDecimal TDouble
+Just (Just TReal)
+
+runMaybeT $ intersection undefined TClafer {_hi = ["A","X","B","C"]} TClafer {_hi = ["X"]}
+Just (Just TClafer {_hi = ["X"]})
 -}
 
-intersection :: Monad m => UIDIClaferMap -> IType -> IType -> m (Maybe IType)
+intersection :: MonadFail m => UIDIClaferMap -> IType -> IType -> m (Maybe IType)
 intersection _              TBoolean        TBoolean      = return $ Just TBoolean
 intersection _              TString         TString       = return $ Just TString
 intersection _              TReal           TReal         = return $ Just TReal
@@ -301,12 +352,24 @@
 intersection _              TDouble         TReal         = return $ Just TReal
 intersection _              TReal           TInteger      = return $ Just TReal
 intersection _              TInteger        TReal         = return $ Just TReal
+intersection _              TDecimal        TDecimal      = return $ Just TDecimal
+intersection _              TDecimal        TInteger      = return $ Just TDecimal
+intersection _              TInteger        TDecimal      = return $ Just TDecimal
+intersection _              TDecimal        TReal         = return $ Just TReal
+intersection _              TReal           TDecimal      = return $ Just TReal
+intersection _              TDecimal        TDouble       = return $ Just TReal
+intersection _              TDouble         TDecimal      = return $ Just TReal
 intersection _              TDouble         TDouble       = return $ Just TDouble
 intersection _              TDouble         TInteger      = return $ Just TDouble
 intersection _              TInteger        TDouble       = return $ Just TDouble
 intersection _              TInteger        TInteger      = return $ Just TInteger
 intersection _              t               (TClafer ["clafer"]) = return $ Just t
 intersection _              (TClafer ["clafer"]) t               = return $ Just t
+-- noclafer, the empty set, is in every set of clafers
+intersection _              t@(TClafer ["noclafer"]) (TClafer _) = return $ Just t
+intersection _              (TClafer _) t@(TClafer ["noclafer"]) = return $ Just t
+intersection _              t@(TClafer ["noclafer"]) (TUnion _)  = return $ Just t
+intersection _              (TUnion _) t@(TClafer ["noclafer"])  = return $ Just t
 intersection uidIClaferMap' (TUnion t1s)    t2@(TClafer _) = do
   t1s' <- mapM (intersection uidIClaferMap' t2) t1s
   return $ case catMaybes t1s' of
@@ -362,7 +425,7 @@
 -- C : A
 -- Outputs:
 -- the resulting type is: A, and the type combination is valid
-getIfThenElseType :: Monad m => UIDIClaferMap -> IType -> IType -> m (Maybe IType)
+getIfThenElseType :: MonadFail m => UIDIClaferMap -> IType -> IType -> m (Maybe IType)
 getIfThenElseType _              TBoolean        TBoolean      = return $ Just TBoolean
 getIfThenElseType _              TString         TString       = return $ Just TString
 getIfThenElseType _              TReal           TReal         = return $ Just TReal
@@ -370,22 +433,29 @@
 getIfThenElseType _              TDouble         TReal         = return $ Just TReal
 getIfThenElseType _              TReal           TInteger      = return $ Just TReal
 getIfThenElseType _              TInteger        TReal         = return $ Just TReal
+getIfThenElseType _              TDecimal        TDecimal      = return $ Just TDecimal
+getIfThenElseType _              TDecimal        TInteger      = return $ Just TDecimal
+getIfThenElseType _              TInteger        TDecimal      = return $ Just TDecimal
+getIfThenElseType _              TDecimal        TReal         = return $ Just TReal
+getIfThenElseType _              TReal           TDecimal      = return $ Just TReal
+getIfThenElseType _              TDecimal        TDouble       = return $ Just TReal
+getIfThenElseType _              TDouble         TDecimal      = return $ Just TReal
 getIfThenElseType _              TDouble         TDouble       = return $ Just TDouble
 getIfThenElseType _              TDouble         TInteger      = return $ Just TDouble
 getIfThenElseType _              TInteger        TDouble       = return $ Just TDouble
 getIfThenElseType _              TInteger        TInteger      = return $ Just TInteger
-getIfThenElseType uidIClaferMap' (TUnion t1s)    t2@(TClafer _) = undefined {- o
-  t1s' <- mapM (getIfThenElseType uidIClaferMap' t2) t1s
-  return $ case catMaybes t1s' of
-    [] -> Nothing
-    [t] -> Just t
-    t1s'' -> Just $ TUnion t1s''  -}
-getIfThenElseType uidIClaferMap' t1@(TClafer _)  (TUnion t2s) = undefined {- do
-  t2s' <- mapM (getIfThenElseType uidIClaferMap' t1) t2s
-  return $ case catMaybes t2s' of
-    [] -> Nothing
-    [t] -> Just t
-    t2s'' -> Just $ TUnion t2s''  -}
+-- noclafer, the empty set, as a branch: the type of the other branch, of clafers
+getIfThenElseType _              (TClafer ["noclafer"]) t@(TClafer _) = return $ Just t
+getIfThenElseType _              t@(TClafer _) (TClafer ["noclafer"]) = return $ Just t
+getIfThenElseType _              (TClafer ["noclafer"]) t@(TUnion _)  = return $ Just t
+getIfThenElseType _              t@(TUnion _)  (TClafer ["noclafer"]) = return $ Just t
+-- Each type of a union must combine with the other branch, e.g., a union of
+-- clafers and booleans does not combine with clafers.
+getIfThenElseType uidIClaferMap' (TUnion t1s)    t2            = combineAll uidIClaferMap' [ (t1, t2) | t1 <- t1s ]
+getIfThenElseType uidIClaferMap' t1              (TUnion t2s)  = combineAll uidIClaferMap' [ (t1, t2) | t2 <- t2s ]
+-- A dereferenced reference, e.g., if c then a.dref else b, has the type of its targets.
+getIfThenElseType uidIClaferMap' (TMap _ ta1)    t2            = getIfThenElseType uidIClaferMap' ta1 t2
+getIfThenElseType uidIClaferMap' t1              (TMap _ ta2)  = getIfThenElseType uidIClaferMap' t1 ta2
 getIfThenElseType uidIClaferMap' t@(TClafer ut1) (TClafer ut2) = if ut1 == ut2
   then return $ Just t
   else do
@@ -406,40 +476,49 @@
     commonHierarchy' _ _ _ = error "ResolverType.commonHierarchy' expects two non empty lists but was given at least one empty list!" -- Should never happen
 getIfThenElseType _ _ _ = return Nothing
 
+-- | The union of the if/then/else types of the pairs, if every pair combines.
+combineAll :: MonadFail m => UIDIClaferMap -> [(IType, IType)] -> m (Maybe IType)
+combineAll uidIClaferMap' pairs = do
+  ts <- mapM (uncurry $ getIfThenElseType uidIClaferMap') pairs
+  return $ foldr1 (+++) <$> (nonEmpty' =<< sequence ts)
+  where
+  nonEmpty' [] = Nothing
+  nonEmpty' xs = Just xs
 
+
 {- | Compute the type of sequential composition of two types
->>> runListT $ composition undefined TString TString
-[Nothing]
+>>> runMaybeT $ composition undefined TString TString
+Just Nothing
 
->>> runListT $ composition undefined TInteger TString
-[Nothing]
+>>> runMaybeT $ composition undefined TInteger TString
+Just Nothing
 
->>> runListT $ composition undefined TInteger TReal
-[Nothing]
+>>> runMaybeT $ composition undefined TInteger TReal
+Just Nothing
 
->>> runListT $ composition undefined tDrefMapDOB TInteger
-[Just (TMap {_so = TClafer {_hi = ["DOB"]}, _ta = TInteger})]
+>>> runMaybeT $ composition undefined tDrefMapDOB TInteger
+Just (Just (TMap {_so = TClafer {_hi = ["DOB"]}, _ta = TInteger}))
 
 Cannot assign a TReal to a map to TInteger, should return [Nothing]
->>> runListT $ composition undefined tDrefMapDOB TReal
-[Just (TMap {_so = TClafer {_hi = ["DOB"]}, _ta = TReal})]
+>>> runMaybeT $ composition undefined tDrefMapDOB TReal
+Just (Just (TMap {_so = TClafer {_hi = ["DOB"]}, _ta = TReal}))
 
 Cannot assign a TInteger to a map to TInteger
->>> runListT $ composition undefined TInteger tDrefMapDOB
-[Nothing]
+>>> runMaybeT $ composition undefined TInteger tDrefMapDOB
+Just Nothing
 
 Cannot assign a TReal to a map to TInteger
->>> runListT $ composition undefined TReal tDrefMapDOB
-[Nothing]
+>>> runMaybeT $ composition undefined TReal tDrefMapDOB
+Just Nothing
 
->>> runListT $ composition undefined tDrefMapDOB (TMap TReal TString)
-[Just (TMap {_so = TClafer {_hi = ["DOB"]}, _ta = TString})]
+>>> runMaybeT $ composition undefined tDrefMapDOB (TMap TReal TString)
+Just (Just (TMap {_so = TClafer {_hi = ["DOB"]}, _ta = TString}))
 
 The following should return [Nothing]
->>> runListT $ composition undefined (TMap TString TReal) (TMap TInteger TString)
-[Just (TMap {_so = TString, _ta = TString})]
+>>> runMaybeT $ composition undefined (TMap TString TReal) (TMap TInteger TString)
+Just (Just (TMap {_so = TString, _ta = TString}))
 -}
-composition :: Monad m => UIDIClaferMap -> IType -> IType -> m (Maybe IType)
+composition :: MonadFail m => UIDIClaferMap -> IType -> IType -> m (Maybe IType)
 composition uidIClaferMap' (TMap so1 ta1) (TMap so2 ta2) = do
     -- check whether we can compose?
     _ <- intersection uidIClaferMap' ta1 so2
@@ -464,7 +543,7 @@
 addHierarchy    uidIClaferMap'   (TUnion un')     = TUnion $ map (addHierarchy uidIClaferMap') un'
 addHierarchy    _                x                = x
 
-closure :: Monad m => UIDIClaferMap -> [String] -> m [String]
+closure :: MonadFail m => UIDIClaferMap -> [String] -> m [String]
 closure uidIClaferMap' ut = concat `liftM` mapM (hierarchyMap uidIClaferMap' _uid) ut
 
 getTMaps :: UIDIClaferMap -> IType        -> [IType]
@@ -487,6 +566,14 @@
 TInteger
 >>> coerce tDrefMapDOB tDrefMapDOB
 TInteger
+>>> coerce (TUnion [TInteger, TReal]) TInteger
+TReal
+
+>>> coerce TInteger TDecimal
+TDecimal
+
+>>> coerce TDecimal TDouble
+TReal
 -}
 
 coerce :: IType -> IType -> IType
@@ -496,6 +583,13 @@
 coerce TInteger TReal    = TReal
 coerce TReal TDouble     = TReal
 coerce TDouble TReal     = TReal
+coerce TDecimal TDecimal = TDecimal
+coerce TDecimal TInteger = TDecimal
+coerce TInteger TDecimal = TDecimal
+coerce TDecimal TReal    = TReal
+coerce TReal TDecimal    = TReal
+coerce TDecimal TDouble  = TReal
+coerce TDouble TDecimal  = TReal
 coerce TDouble TDouble   = TDouble
 coerce TDouble TInteger  = TDouble
 coerce TInteger TDouble  = TDouble
@@ -504,6 +598,9 @@
 coerce (TMap _ t1) (TMap _ t2) = coerce t1 t2
 coerce (TMap _ t1) t2          = coerce t1 t2
 coerce t1          (TMap _ t2) = coerce t1 t2
+-- unions of numeric types (see 'allNumeric')
+coerce (TUnion un1) t2         = coerce (foldr1 coerce un1) t2
+coerce t1          (TUnion un2) = coerce t1 (foldr1 coerce un2)
 coerce x y = error $ "TypeSystem.coerce: Cannot coerce not numeric: " ++ show x ++ " and " ++ show y
 
 
diff --git a/src/Language/Clafer/Intermediate/UIDs.hs b/src/Language/Clafer/Intermediate/UIDs.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Clafer/Intermediate/UIDs.hs
@@ -0,0 +1,73 @@
+{-
+ Copyright (C) 2026 Michal Antkiewicz <http://gsd.uwaterloo.ca>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-}
+{- | The UIDs of the clafers: the names, qualified only as much as needed.
+
+The UID of a clafer is its least-partially-qualified name, with @__@ between the names: @size@
+if no other clafer is named @size@; @x__size@ for the @size@ in @x@, if another @size@ exists
+elsewhere; @root__size@ for a top-level @size@ that is also the end of another clafer's path
+(@root@ is a keyword, so no path of names starts with it). A UID is an identifier of Clafer, so
+an explicit model needs only unique names, and nothing has to parse a UID to get a clafer's name:
+it is the clafer's @_ident@.
+
+* An apostrophe is written @_prime@: @a'@ is @a_prime@.
+* A UID that equals the UID of a clafer before it in the model (e.g., @a_prime@ next to @a'@,
+  or two siblings with the same name) gets the first free suffix @__2@, @__3@, ...: no path of
+  names has a part that starts with a digit, so a suffix never equals a qualified name.
+
+The UIDs do not depend on the outputs: each generator writes them in the form its target
+language allows, e.g., the Alloy generator renames a UID that is an Alloy keyword
+("Language.Clafer.Generator.AlloyNames").
+-}
+module Language.Clafer.Intermediate.UIDs
+  ( assignUIDs
+  , uidSegment
+  ) where
+
+import           Data.List
+import qualified Data.Map as Map
+import           Data.Maybe
+import qualified Data.Set as Set
+
+import           Language.Clafer.Common
+import           Language.Clafer.Intermediate.Intclafer (UID)
+
+-- | The UIDs of the clafers with the given paths (the names of the clafer and its ancestors,
+--   from the top level), in the same order. The paths are those of all clafers of a model.
+assignUIDs :: [[String]] -> [UID]
+assignUIDs paths = snd $ mapAccumL fresh Set.empty $ map candidate reversedPaths
+  where
+    reversedPaths = map reverse paths
+    -- for each suffix of a path (reversed), the number of clafers whose paths end with it
+    suffixCounts :: Map.Map [String] Int
+    suffixCounts = Map.fromListWith (+) [ (s, 1) | rp <- reversedPaths, s <- nub $ tail $ inits rp ]
+    endWith s = Map.findWithDefault 0 s suffixCounts
+    candidate rp = case [ s | k <- [1 .. length rp], let s = take k rp, endWith s == 1 ] of
+      (s : _) -> render s
+      -- the full path is also the end of another clafer's path: from the root
+      [] -> render (rp ++ [rootIdent])
+    render = intercalate "__" . map uidSegment . reverse
+    fresh used uid' = (Set.insert chosen used, chosen)
+      where chosen = fromJust $ find (`Set.notMember` used) $ uid' : [ uid' ++ "__" ++ show n | n <- [2 :: Int ..] ]
+
+-- | A name as a part of a UID: an apostrophe, which identifiers cannot contain, is _prime.
+uidSegment :: String -> String
+uidSegment = concatMap (\c -> if c == '\'' then "_prime" else [c])
diff --git a/src/Language/Clafer/JSONMetaData.hs b/src/Language/Clafer/JSONMetaData.hs
--- a/src/Language/Clafer/JSONMetaData.hs
+++ b/src/Language/Clafer/JSONMetaData.hs
@@ -31,11 +31,12 @@
 
 where
 
-import Control.Lens hiding (element)
+import Control.Lens hiding ((.=))
+import Data.Aeson ((.=))
+import Data.Aeson.Encoding (Encoding, encodingToLazyByteString, list, pairs)
 import Data.Aeson.Lens
 import qualified Data.List as List
 import Data.Maybe
-import Data.Json.Builder
 import Data.String.Conversions
 import qualified Data.Text as T
 import System.FilePath
@@ -47,33 +48,33 @@
 -- | Both the FQNames and UIDs are brittle. LPQNames are the least brittle.
 generateJSONnameUIDMap :: QNameMaps -> String
 generateJSONnameUIDMap    qNameMaps     =
-    prettyPrintJSON $ convertString $ toJsonBS $ foldl generateQNameUIDArrayEntry mempty sortedTriples
+    prettyPrintJSON $ convertString $ encodingToLazyByteString $ list generateQNameUIDArrayEntry sortedTriples
     where
       sortedTriples :: [(FQName, PQName, UID)]
       sortedTriples = List.sortBy (\(fqName1, _, _) (fqName2, _, _) -> compare fqName1 fqName2) $ getQNameUIDTriples qNameMaps
 
-generateQNameUIDArrayEntry :: Array -> (FQName, PQName, UID) -> Array
-generateQNameUIDArrayEntry    array    (fqName, lpqName, uid) =
-    mappend array $ element $ mconcat [
-        row ("fqName" :: String) fqName,
-        row ("lpqName" :: String) lpqName,
-        row ("uid" :: String) uid ]
+generateQNameUIDArrayEntry :: (FQName, PQName, UID) -> Encoding
+generateQNameUIDArrayEntry    (fqName, lpqName, uid) =
+    pairs $ mconcat [
+        "fqName" .= fqName,
+        "lpqName" .= lpqName,
+        "uid" .= uid ]
 
 -- | Generate a JSON list of tuples containing a least-partially-qualified name and a scope
 generateJSONScopes :: QNameMaps -> [(UID, Integer)] -> String
 generateJSONScopes    qNameMaps    scopes       =
-    prettyPrintJSON $ convertString $ toJsonBS $ foldl generateLpqNameScopeArrayEntry mempty sortedLpqNameScopeList
+    prettyPrintJSON $ convertString $ encodingToLazyByteString $ list generateLpqNameScopeArrayEntry sortedLpqNameScopeList
     where
       lpqNameScopeList = map (\(uid, scope) -> (fromMaybe uid $ getLPQName qNameMaps uid, scope)) scopes
       sortedLpqNameScopeList :: [(PQName, Integer)]
       sortedLpqNameScopeList = List.sortBy (\(lpqName1, _) (lpqName2, _) -> compare lpqName1 lpqName2) lpqNameScopeList
 
 
-generateLpqNameScopeArrayEntry :: Array -> (PQName, Integer)   -> Array
-generateLpqNameScopeArrayEntry    array    (lpqName, scope) =
-    mappend array $ element $ mconcat [
-        row ("lpqName" :: String) lpqName,
-        row ("scope" :: String) scope ]
+generateLpqNameScopeArrayEntry :: (PQName, Integer) -> Encoding
+generateLpqNameScopeArrayEntry    (lpqName, scope) =
+    pairs $ mconcat [
+        "lpqName" .= lpqName,
+        "scope" .= scope ]
 
 -- insert a new line after  [, {, and ,
 prettyPrintJSON :: String -> String
@@ -87,22 +88,25 @@
 prettyPrintJSON (c:line) =  c:prettyPrintJSON line
 prettyPrintJSON ""         = ""
 
--- | given the QNameMaps, parse the JSON scopes and return list of scopes
+-- | given the QNameMaps, parse the JSON scopes and return list of scopes.
+-- | Only the entries {"lpqName": name, "scope": n} are clafer scopes; the others, e.g., chocosolver's
+-- | {"int": [low, high]} or {"defaultScope": n}, are skipped.
 parseJSONScopes :: QNameMaps -> String    -> [ (UID, Integer) ]
 parseJSONScopes    qNameMaps    scopesJSON =
     foldl (\uidScopes qScope -> qNameToUIDs qScope ++ uidScopes) [] decodedScopes
     where
       --                  QName
       decodedScopes :: [ (T.Text, Integer) ]
-      decodedScopes = scopesJSON ^.. _Array . traverse
-                                       . to (\o -> ( o ^?! key "lpqName" . _String
-                                                   , o ^?! key "scope"  . _Integer)
-                                            )
-      -- a QName may resolve to potentially multiple UIDs
+      decodedScopes = mapMaybe claferScope $ scopesJSON ^.. _Array . traverse
+      claferScope o = (,) <$> o ^? key "lpqName" . _String <*> o ^? key "scope" . _Integer
+      -- a UID names its clafer; a QName may resolve to potentially multiple UIDs
       qNameToUIDs :: (T.Text, Integer) -> [ (UID, Integer) ]
-      qNameToUIDs   (qName, scope)  = if T.null qName
-                                       then [ ("", scope) ]
-                                       else [ (uid, scope) | uid <- getUIDs qNameMaps $ convertString qName]
+      qNameToUIDs   (qName, scope)
+        | T.null qName                       = [ ("", scope) ]
+        | isJust $ getFQName qNameMaps name  = [ (name, scope) ]
+        | otherwise                          = [ (uid, scope) | uid <- getUIDs qNameMaps name ]
+        where
+          name = convertString qName
 
 -- | Write a .cfr-scope file
 writeCfrScopeFile :: [ (UID, Integer) ] -> QNameMaps -> FilePath        -> IO ()
diff --git a/src/Language/Clafer/Optimizer/Optimizer.hs b/src/Language/Clafer/Optimizer/Optimizer.hs
--- a/src/Language/Clafer/Optimizer/Optimizer.hs
+++ b/src/Language/Clafer/Optimizer/Optimizer.hs
@@ -26,6 +26,7 @@
 import Data.List
 import Control.Applicative
 import Control.Lens hiding (elements, children, un)
+import Control.Monad
 import Control.Monad.State
 import Data.Data.Lens (biplate)
 import qualified Data.Map as Map
@@ -69,6 +70,7 @@
 
 -- -----------------------------------------------------------------------------
 
+-- | Abstract clafers which no concrete clafer extends get no instances.
 makeZeroUnusedAbs :: [IElement] -> [IElement]
 makeZeroUnusedAbs decls' = map (\x -> if (x `elem` unusedAbs) then IEClafer (getIClafer x){_card = Just (0, 0)} else x) decls'
   where
@@ -78,14 +80,37 @@
   getIClafer (IEClafer c) = c
   getIClafer _ = error "Function makeZeroUnusedAbs from Optimizer expected paramter of type IClafer got a differnt IElement" --This should never happen
 
+-- | Removes the abstract clafers which no concrete clafer extends, unless a
+-- reference or a constraint names them: those are kept, without instances.
 remUnusedAbs :: [IElement] -> [IElement]
-remUnusedAbs decls' = decls' \\ unusedAbs
+remUnusedAbs decls' = makeZeroUnusedAbs $ decls' \\ unneededAbs
   where
-  unusedAbs = map IEClafer $ findUnusedAbs clafers $ map _uid $
-              filter (not._isAbstract) clafers
-  clafers   = toClafers decls'
+  unneededAbs = map IEClafer $ findUnneededAbs clafers $ neededRoots decls'
+  clafers     = toClafers decls'
 
+-- | The clafers needed to begin with: the concrete clafers and the clafers
+-- named in constraints.
+neededRoots :: [IElement] -> [String]
+neededRoots decls' =
+  map _uid (filter (not . _isAbstract) $ toClafers decls')
+  ++ [ sid | pexp <- constraints decls', IClaferId{_sident = sid} <- universeOn biplate pexp ]
+  where
+  constraints = concatMap constraint
+  constraint (IEConstraint _ pexp) = [pexp]
+  constraint (IEClafer c)          = constraints $ _elements c
+  constraint _                     = []
 
+-- | Like 'findUnusedAbs', but a clafer also needs the targets of its reference
+-- and those of its subclafers.
+findUnneededAbs :: [IClafer] -> [String] -> [IClafer]
+findUnneededAbs maybeNeeded [] = maybeNeeded
+findUnneededAbs [] _ = []
+findUnneededAbs maybeNeeded needed = findUnneededAbs maybeNeeded' $ nub $ needed' >>= getNeeded
+  where
+  (needed', maybeNeeded') = partition (\c -> _uid c `elem` needed) maybeNeeded
+  getNeeded c = getSuper c ++ getReference c ++ ((getSubclafers $ _elements c) >>= getNeeded)
+
+
 findUnusedAbs :: [IClafer] -> [String] -> [IClafer]
 findUnusedAbs maybeUsed [] = maybeUsed
 findUnusedAbs [] _   = []
@@ -177,19 +202,20 @@
 split' _ _ = error "Function split' from Optimizer expects an argument of type ClaferId or IFunExp but was given another IExp"
 
 -- -----------------------------------------------------------------------------
--- checking if all clafers have unique names and don't extend other clafers
+-- checking if the names of all clafers can be their UIDs
 
+-- | Whether the name of every clafer can be its UID, so that `-f` can skip renaming.
 allUnique :: IModule -> Bool
-allUnique iModule = dontExtend && identsUnique
+allUnique = null . nonUidNames
+
+-- | The clafers whose names cannot be their UIDs: a name of several clafers, or a name with an
+-- | apostrophe, which a UID cannot contain (see Language.Clafer.Intermediate.UIDs).
+nonUidNames :: IModule -> [ IClafer ]
+nonUidNames iModule = filter (\c -> '\'' `elem` _ident c || Map.findWithDefault 0 (_ident c) counts > (1 :: Int)) allClafers
   where
     allClafers :: [ IClafer ]
     allClafers = universeOn biplate iModule
-
-    -- True when getSuper always returns Nothing and therefore concatMap returned []
-    dontExtend = null $ concatMap getSuper allClafers
-    allIdents = map _ident allClafers
-    -- all idents are unique when nub cannot remove any duplicates
-    identsUnique = (length allIdents) == (length $ nub allIdents)
+    counts = Map.fromListWith (+) [ (_ident c, 1) | c <- allClafers ]
 
 checkConstraintElement :: [String] -> IElement -> Bool
 checkConstraintElement idents x = case x of
diff --git a/src/Language/Clafer/QNameUID.hs b/src/Language/Clafer/QNameUID.hs
--- a/src/Language/Clafer/QNameUID.hs
+++ b/src/Language/Clafer/QNameUID.hs
@@ -1,5 +1,5 @@
 {-
- Copyright (C) 2014-2017 Michal Antkiewicz <http://gsd.uwaterloo.ca>
+ Copyright (C) 2014-2026 Michal Antkiewicz <http://gsd.uwaterloo.ca>
 
  Permission is hereby granted, free of charge, to any person obtaining a copy of
  this software and associated documentation files (the "Software"), to deal in
@@ -19,7 +19,18 @@
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
 -}
--- | Support for dealing with unique IDs (UIDs), fully- and least-partially qualified names.
+{- | Fully- and least-partially-qualified names of clafers, and the clafers that a name names.
+
+The least-partially-qualified (LPQ) name of a clafer is its UID (see
+"Language.Clafer.Intermediate.UIDs"): its name, qualified with the names of its ancestors only as
+much as needed to be unique, with @__@ between the names, e.g., @size@, @x__size@ or
+@root__size@. The fully-qualified name has all of them, from the root, e.g., @root__x__size@.
+
+A name names the clafer whose UID it is; otherwise, split on @__@, all the clafers whose paths of
+names end with it, e.g., @size@ names every clafer named @size@, @x__size@ every @size@ in an
+@x@, and @root__size@ only a top-level @size@. The older form with @::@ is read too: @x::size@ is
+@x__size@, and @::size@ is @root__size@.
+-}
 module Language.Clafer.QNameUID (
         QName,
         FQName,
@@ -35,127 +46,61 @@
 
 where
 
-import Data.Maybe
+import Data.List
 import Data.List.Split
 import qualified Data.Map as Map
-import qualified Data.StringMap as SMap
 
+import Language.Clafer.Common (rootIdent)
 import Language.Clafer.Intermediate.Intclafer
 
 -- | a fully- or partially-qualified name
 type QName = String
 
--- | fully-qualified name, must begin with ::
--- | e.g., `::Person::name`, `::Company::Department::chair`
+-- | fully-qualified name, from the root, e.g., `root__Person__name`
 type FQName = String
 
--- a reversed FQName used as a key in the FQNameUIDMap
-type FQKey = String
-
--- | partially-qualified name, must not begin with ::
--- | e.g., `Person::name`, `chair`
+-- | partially-qualified name, e.g., `Person__name`, `chair`
 type PQName = String
 
--- a map from reversed FQName (FQKey) to UID
-type FQNameUIDMap = SMap.StringMap UID
-
-type UIDFqNameMap = Map.Map UID FQName
-type UIDLpqNameMap = Map.Map UID PQName
+-- | the clafers by UID, in the order of the model: the names of each clafer and its ancestors,
+--   from the top level
+data QNameMaps = QNameMaps [(UID, [String])] (Map.Map UID [String])
 
--- | maps between fully-, least-partially-qualified names and UIDs
-data QNameMaps =  QNameMaps FQNameUIDMap UIDFqNameMap UIDLpqNameMap
+-- | the UIDs of the clafers that a name names: one for a UID, possibly many for a partially
+--   qualified name
+getUIDs :: QNameMaps -> QName -> [UID]
+getUIDs (QNameMaps paths pathOf) qName
+  | Map.member qName pathOf = [qName]
+  | null names              = []
+  | otherwise               = [ uid' | (uid', path) <- paths, if fromRoot then path == names else names `isSuffixOf` path ]
+  where
+    (fromRoot, names) = case qName of
+      ':' : ':' : rest -> (True, splitOn "::" rest)
+      _ | "::" `isInfixOf` qName -> (False, splitOn "::" qName)
+      _ -> case splitOn "__" qName of
+        (r : rest@(_ : _)) | r == rootIdent -> (True, rest)
+        parts -> (False, parts)
 
--- | get the UID of a clafer given a fully qualifed name or potentially many UIDs given a partially qualified name
-getUIDs :: QNameMaps                 -> QName -> [UID]
-getUIDs    (QNameMaps fqNameUIDMap _ _) qName = findUIDsByFQName fqNameUIDMap qName
+-- | the fully-qualified name of a clafer given its UID
+getFQName :: QNameMaps -> UID -> Maybe FQName
+getFQName (QNameMaps _ pathOf) uid' = fqName <$> Map.lookup uid' pathOf
 
--- | get the fully-qualified name of a clafer given its UID
-getFQName :: QNameMaps                 -> UID -> Maybe FQName
-getFQName    (QNameMaps _ uidFqNameMap _) uid' = Map.lookup uid' uidFqNameMap
+-- | the least-partially-qualified name of a clafer given its UID: the UID
+getLPQName :: QNameMaps -> UID -> Maybe PQName
+getLPQName (QNameMaps _ pathOf) uid' = if Map.member uid' pathOf then Just uid' else Nothing
 
--- | get the least-partially-qualified name of a clafer given its UID
-getLPQName :: QNameMaps                 -> UID -> Maybe PQName
-getLPQName    (QNameMaps _ _ uidLpqNameMap) uid' = Map.lookup uid' uidLpqNameMap
+fqName :: [String] -> FQName
+fqName = intercalate "__" . (rootIdent :)
 
--- | derive maps between fully-, partially-qualified names, and UIDs
+-- | derive the names of the clafers of a module
 deriveQNameMaps :: IModule -> QNameMaps
-deriveQNameMaps    iModule =
-    let
-        (fqNameUIDMap, uidFqNameMap) = deriveFQNameUIDMaps iModule
-        uidLpqNameMap = deriveUidLpqNameMap fqNameUIDMap
-    in
-        QNameMaps fqNameUIDMap uidFqNameMap uidLpqNameMap
-
-deriveFQNameUIDMaps :: IModule -> (FQNameUIDMap, UIDFqNameMap)
-deriveFQNameUIDMaps    iModule = addElements ["::"] (_mDecls iModule) (SMap.empty, Map.empty)
-
-addElements :: [String] -> [IElement] -> (FQNameUIDMap, UIDFqNameMap) -> (FQNameUIDMap, UIDFqNameMap)
-addElements    path        elems         maps                         = foldl (addClafer path) maps elems
-
-addClafer :: [String] -> (FQNameUIDMap, UIDFqNameMap) -> IElement          -> (FQNameUIDMap, UIDFqNameMap)
-addClafer    path        (fqNameUIDMap, uidFqNameMap)    (IEClafer iClaf) =
-    let
-        newPath = _ident iClaf : path
-        fqKey :: FQKey
-        fqKey = concat newPath
-        fqName :: FQName
-        fqName = getQNameFromKey fqKey
-        fqNameUIDMap' = SMap.insert fqKey (_uid iClaf) fqNameUIDMap
-        uidFqNameMap' = Map.insert (_uid iClaf) fqName uidFqNameMap
-    in
-        addElements ("::" : newPath) (_elements iClaf) (fqNameUIDMap', uidFqNameMap')
-addClafer    _           maps                            _                  = maps
-
-findUIDsByFQName :: FQNameUIDMap -> FQName            -> [ UID ]
-findUIDsByFQName    fqNameUIDMap    fqName@(':':':':_) = SMap.lookup (getFQKey fqName) fqNameUIDMap
-findUIDsByFQName    fqNameUIDMap    fqName             = SMap.prefixFind (getFQKey fqName) fqNameUIDMap
-
-reverseOnQualifier :: FQName -> FQName
-reverseOnQualifier fqName = concat $ reverse $ split (onSublist "::") fqName
-
-getFQKey :: FQName -> FQKey
-getFQKey = reverseOnQualifier
-
-getQNameFromKey :: FQKey -> QName
-getQNameFromKey = reverseOnQualifier
-
-deriveUidLpqNameMap :: FQNameUIDMap ->  UIDLpqNameMap
-deriveUidLpqNameMap    fqNameUIDMap =
-    SMap.foldrWithKey (generateUIDLpqMapEntry fqNameUIDMap) Map.empty fqNameUIDMap
-
-generateUIDLpqMapEntry :: FQNameUIDMap ->  SMap.Key -> UID -> UIDLpqNameMap -> UIDLpqNameMap
-generateUIDLpqMapEntry    fqNameUIDMap     fqKey       uid'   uidLpqNameMap =
-    Map.insert uid' lpqName uidLpqNameMap
-    where
-      -- need to reverse the key to get a fully qualified name
-      fqName :: FQName
-      fqName = getQNameFromKey fqKey
-
-      -- name qualified just sufficiently to uniquely identify the clafer
-      -- can be both FQName or PQName
-      lpqName :: QName
-      lpqName = findLeastQualifiedName fqName fqNameUIDMap
-
-      findLeastQualifiedName :: String -> FQNameUIDMap -> String
-      -- handle fully qualified name case
-      findLeastQualifiedName fqName'@(':':':':pqName) fqNameUIDMap' =
-          if (length (findUIDsByFQName fqNameUIDMap' pqName) > 1)
-              then fqName'
-              else findLeastQualifiedName pqName fqNameUIDMap'
-      -- handle partially qualified name case
-      findLeastQualifiedName pqName fqNameUIDMap' =
-         let
-            -- remove one segment of qualification
-            lessQName =  concat $ drop 2 $ split (onSublist "::") pqName
-         in
-            if (length (findUIDsByFQName fqNameUIDMap' lessQName) > 1)
-              then pqName
-              else findLeastQualifiedName lessQName fqNameUIDMap'
+deriveQNameMaps iModule = QNameMaps paths (Map.fromList paths)
+  where
+    paths = concatMap (claferPaths []) $ _mDecls iModule
+    claferPaths path (IEClafer iClaf) = (_uid iClaf, path') : concatMap (claferPaths path') (_elements iClaf)
+      where path' = path ++ [_ident iClaf]
+    claferPaths _ _ = []
 
+-- | the fully-qualified name, the least-partially-qualified name and the UID of each clafer
 getQNameUIDTriples :: QNameMaps -> [(FQName, PQName, UID)]
-getQNameUIDTriples qNameMaps@(QNameMaps _ uidFqNameMap _) =
-    let
-      uidFqNameList :: [(UID, FQName)]
-      uidFqNameList = Map.toList uidFqNameMap
-    in
-      map (\(uid', fqName) -> (fqName, fromMaybe fqName $ getLPQName qNameMaps uid', uid')) uidFqNameList
+getQNameUIDTriples (QNameMaps paths _) = [ (fqName path, uid', uid') | (uid', path) <- paths ]
diff --git a/src/Language/Clafer/clafer.css b/src/Language/Clafer/clafer.css
--- a/src/Language/Clafer/clafer.css
+++ b/src/Language/Clafer/clafer.css
@@ -1,14 +1,15 @@
 .identifier{}
-.keyword{font-weight:bold}
+.keyword{font-weight: bold;}
+.tKeyword{font-style: oblique;}
 .reference{}
-.code { background-color: lightgray; padding: 5px 5px 5px 5px; border: 1px solid darkgray; margin-bottom: 15px; 
+.code { background-color: lightgray; padding: 5px 5px 5px 5px; border: 1px solid darkgray; margin-bottom: 15px;
         font-family: Pragmata, Menlo, 'DejaVu LGC Sans Mono', 'DejaVu Sans Mono', Consolas, 'Everson Mono', 'Lucida Console', 'Andale Mono', 'Nimbus Mono L', 'Liberation Mono', FreeMono, 'Osaka Monospaced', Courier, 'New Courier', monospace; }
 .standalonecomment { color: green; font-style:italic }
 .inlinecomment { color: green; padding-left:20px; font-style:italic }
 .error{background-color: yellow; color: red }
 .deprecated{color: orange }
 .indent{padding-left:20px}
+.file { font-weight: bold; border-bottom: 1px solid darkgray; margin: 1em 0 0.5em 0 }
 a[href$='Lookup failed'] {color: red}
 a[href$='Uid not found'] {color: red}
 a[href$='Ambiguous name'] {color: yellow}
-
diff --git a/src/Language/ClaferT.hs b/src/Language/ClaferT.hs
--- a/src/Language/ClaferT.hs
+++ b/src/Language/ClaferT.hs
@@ -56,6 +56,7 @@
   , Pos(..)
   ) where
 
+import           Control.Monad
 import           Control.Monad.Except
 import           Control.Monad.Identity
 import           Control.Monad.State
@@ -66,6 +67,7 @@
 import           Language.Clafer.Common
 import           Language.Clafer.Front.AbsClafer
 import           Language.Clafer.Front.LexClafer
+import           Language.Clafer.Import (ModelFile)
 import           Language.Clafer.Intermediate.Intclafer
 import           Language.Clafer.Intermediate.Tracing
 
@@ -106,6 +108,7 @@
     , frags          :: [Pos]    -- line numbers of fragment markers
     , astModuleTrace :: Map.Map Span [Ast]  -- can keep the Ast map since it never changes
     , otherTokens    :: [Token]  -- non-parseable tokens: comments and escape blocks
+    , inputFiles     :: [ModelFile] -- the files of the model, in the order of the model's text; none if not known
     } deriving Show
 
 -- | This simulates a field in the ClaferEnv that will always recompute the map,
@@ -149,6 +152,7 @@
     , frags = []
     , astModuleTrace = Map.empty
     , otherTokens = []
+    , inputFiles = []
     }
   where
     args'' = if (CVLGraph `elem` (mode args') ||
@@ -284,7 +288,7 @@
 throwErrs :: (Monad m, Throwable t) => [t] -> ClaferT m a
 throwErrs throws =
   do
-    errors <- mapM toErr throws
+    errors <- mapM (\e -> toErr e) throws
     throwError $ ClaferErrs errors
 
 -- | Throw one error.
diff --git a/stack.yaml b/stack.yaml
--- a/stack.yaml
+++ b/stack.yaml
@@ -1,9 +1,15 @@
-# for GHC-8.0.2
-extra-deps:
-  - data-stringmap-1.0.1.1
-  - json-builder-0.3
-resolver: lts-8.5
+# for GHC-9.12.4
+resolver: nightly-2026-11-11
 
-flags: {}
+flags:
+  # The test suite that compiles the models in test/positive and test/negative.
+  clafer:
+    model-tests: true
 packages:
 - '.'
+
+# GHC compiles the modules of a package on 8 threads, which takes a third less time than one
+# thread; 16 threads are not faster.
+# (build: semaphore: true, GHC's -jsem, fails with Stack 3.11.1: "semOpen: does not exist".)
+ghc-options:
+  "$everything": -j8
diff --git a/test/Suite/Negative.hs b/test/Suite/Negative.hs
--- a/test/Suite/Negative.hs
+++ b/test/Suite/Negative.hs
@@ -37,7 +37,7 @@
     claferModels <- getClafers "test/negative"
     return $ filter ((`notElem` crashModels) . fst ) claferModels
     where
-        crashModels = ["i127-loop.cfr", "i141-constraints.cfr"]
+        crashModels = []
 {-Put models in the list above that completly crash
   the compiler, this will avoid crashing the test suite
   Note: If the model is giving an unexpected error it
diff --git a/test/Suite/Positive.hs b/test/Suite/Positive.hs
--- a/test/Suite/Positive.hs
+++ b/test/Suite/Positive.hs
@@ -28,6 +28,7 @@
 import Data.Maybe
 import Control.Monad
 import Language.Clafer
+import Language.Clafer.Import (readModel, modelText)
 import Language.ClaferT
 import Test.Tasty
 import Test.Tasty.HUnit
@@ -38,8 +39,13 @@
 tg_Test_Suite_Positive :: TestTree
 tg_Test_Suite_Positive = $(testGroupGenerator)
 
+-- | The models with the models they import (//# OPTIONS --import), compiled together
 positiveClaferModels :: IO [(String, String)]
-positiveClaferModels = getClafers "test/positive"
+positiveClaferModels = do
+    claferModels <- getClafers "test/positive"
+    forM claferModels (\(file', model) -> do
+        modelFiles <- readModel defaultClaferArgs{file = "test/positive/" ++ file'}
+        return (file', either (const model) (modelText . snd) modelFiles))
 
 case_compileTest :: Assertion
 case_compileTest = do
@@ -52,10 +58,10 @@
 
 case_reference_Unused_Abstract_Clafer :: Assertion
 case_reference_Unused_Abstract_Clafer = do
-    model <- readFile "test/positive/i235.cfr"
+    model <- readFile "test/positive/reference_to_unextended_abstract.cfr"
     let compiledClafers = [("None", compileOneFragment defaultClaferArgs{scope_strategy = None} model), ("Simple", compileOneFragment defaultClaferArgs{scope_strategy = Simple} model)]
     forM_ compiledClafers (\(ss, compiled) ->
-        when (not $ compiledCheck compiled) $ putStrLn ("i235.cfr failed for scope_strategy = " ++ ss))
+        when (not $ compiledCheck compiled) $ putStrLn ("reference_to_unextended_abstract.cfr failed for scope_strategy = " ++ ss))
     (andMap (compiledCheck . snd) compiledClafers
         @? "reference_Unused_Abstract_Clafer (i235) failed, error for referencing unused abstract clafer")
 
@@ -81,3 +87,23 @@
 case_stringEqual = do
     let strMap = stringMap $ fromJust $ Map.lookup Alloy $ fromRight $ compileOneFragment defaultClaferArgs "A\n    text1 -> string = \"some text\"\n    text2 -> string = \"some text\""
     (Map.size strMap) == 1 @? "Error: same string assigned to differnet numbers!"
+
+-- | In a dynamic model, an enumeration and its literals are final (#92); in a static
+--   model, they are not, so that the enumeration does not make the model dynamic.
+case_enumFinalInDynamicModel :: Assertion
+case_enumFinalInDynamicModel = do
+    let
+        enumeration = "enum UserRequest = stop | up | down\nElevator\n    request -> UserRequest\n"
+        dynamicModel = enumeration ++ "    [ initially request = stop ]\n"
+        staticModel = enumeration ++ "    [ request = stop ]\n"
+        finality model = case Map.lookup Alloy $ fromRight $ compileOneFragment defaultClaferArgs model of
+            Just CompilerResult{claferEnv = ClaferEnv{cIr = Just (iMod, _, _)}} -> foldMapIR enumFinality iMod
+            _ -> []
+        enumFinality (IRClafer c) | _ident c `elem` ["UserRequest", "stop", "up", "down"] = [(_ident c, _isFinal c)]
+        enumFinality _ = []
+    map fst (finality dynamicModel) == ["UserRequest", "stop", "up", "down"]
+        @? "The enumeration is missing from the IR: " ++ show (finality dynamicModel)
+    all snd (finality dynamicModel)
+        @? "The enumeration is not final in a dynamic model: " ++ show (finality dynamicModel)
+    not (any snd (finality staticModel))
+        @? "The enumeration is final in a static model: " ++ show (finality staticModel)
diff --git a/test/Suite/Redefinition.hs b/test/Suite/Redefinition.hs
--- a/test/Suite/Redefinition.hs
+++ b/test/Suite/Redefinition.hs
@@ -32,7 +32,6 @@
 import           Control.Applicative
 import qualified Data.Map as M
 import           Data.Maybe (isNothing, isJust, fromJust)
-import           Data.StringMap
 import           Test.Tasty
 import           Test.Tasty.HUnit
 import           Test.Tasty.TH
@@ -69,29 +68,29 @@
     Right compilerResultMap -> case M.lookup Alloy compilerResultMap of
         Nothing -> assertFailure "No Alloy result in the result map"
         Just compilerResult -> let
-                uidIClaferMap' :: StringMap IClafer
+                uidIClaferMap' :: M.Map String IClafer
                 uidIClaferMap' = uidIClaferMap $ claferEnv compilerResult
-                c0_req = fromJust $ findIClafer uidIClaferMap' "c0_req"
+                c0_req = fromJust $ findIClafer uidIClaferMap' "Controller__req"
                 c0_req_match = matchNestedInheritance uidIClaferMap' c0_req
-                c1_req = fromJust $ findIClafer uidIClaferMap' "c1_req"
+                c1_req = fromJust $ findIClafer uidIClaferMap' "WinController__req"
                 c1_req_match = matchNestedInheritance uidIClaferMap' c1_req
-                c0_cmd = fromJust $ findIClafer uidIClaferMap' "c0_cmd"
+                c0_cmd = fromJust $ findIClafer uidIClaferMap' "cmd"
                 c0_cmd_match = matchNestedInheritance uidIClaferMap' c0_cmd
-                c0_Component = fromJust $ findIClafer uidIClaferMap' "c0_Component"
+                c0_Component = fromJust $ findIClafer uidIClaferMap' "Component"
                 c0_Component_match = matchNestedInheritance uidIClaferMap' c0_Component
-                c0_InPort = fromJust $ findIClafer uidIClaferMap' "c0_InPort"
+                c0_InPort = fromJust $ findIClafer uidIClaferMap' "InPort"
                 c0_InPort_match = matchNestedInheritance uidIClaferMap' c0_InPort
-                c0_WinController = fromJust $ findIClafer uidIClaferMap' "c0_WinController"
+                c0_WinController = fromJust $ findIClafer uidIClaferMap' "WinController"
                 c0_WinController_match = matchNestedInheritance uidIClaferMap' c0_WinController
-                c0_down = fromJust $ findIClafer uidIClaferMap' "c0_down"
+                c0_down = fromJust $ findIClafer uidIClaferMap' "down"
                 c0_down_match = matchNestedInheritance uidIClaferMap' c0_down
-                c0_Exception = fromJust $ findIClafer uidIClaferMap' "c0_Exception"
+                c0_Exception = fromJust $ findIClafer uidIClaferMap' "Exception"
                 c0_Exception_match = matchNestedInheritance uidIClaferMap' c0_Exception
-                c0_powerDown = fromJust $ findIClafer uidIClaferMap' "c0_powerDown"
+                c0_powerDown = fromJust $ findIClafer uidIClaferMap' "powerDown"
                 c0_powerDown_match = matchNestedInheritance uidIClaferMap' c0_powerDown
-                {-c0_Alice = fromJust $ findIClafer uidIClaferMap' "c0_Alice"
+                {-c0_Alice = fromJust $ findIClafer uidIClaferMap' "Alice"
                 c0_Alice_match = matchNestedInheritance uidIClaferMap' c0_Alice
-                c0_Bob = fromJust $ findIClafer uidIClaferMap' "c0_Bob"
+                c0_Bob = fromJust $ findIClafer uidIClaferMap' "Bob"
                 c0_Bob_match = matchNestedInheritance uidIClaferMap' c0_Bob-}
             in do
                 isJust c0_req_match @? ("NestedInheritanceMatch not found for " ++ show c0_req)
@@ -123,8 +122,8 @@
                 (isProperNesting uidIClaferMap' (c0_powerDown_match)) @? ("Improper nesting for " ++ show c0_powerDown)
 
                 (not $ isTopLevel c0_Exception) @? ("isTopLevel c0_Exception must return False")
-                _parentUID c0_Exception == "c0_Component" @? ("Parent of c0_Exception should be c0_Component but it is " ++ _parentUID c0_Exception)
-                (_uid <$> _parentClafer <$> c0_Exception_match) == (Just "c0_Component") @? ("_parentClafer of c0_Exception should be c0_Component in the match")
+                _parentUID c0_Exception == "Component" @? ("Parent of c0_Exception should be c0_Component but it is " ++ _parentUID c0_Exception)
+                (_uid <$> _parentClafer <$> c0_Exception_match) == (Just "Component") @? ("_parentClafer of c0_Exception should be c0_Component in the match")
                {- isJust c0_Alice_match @? ("NestedInheritanceMatch not found for " ++ show c0_Alice)
                 isProperNesting uidIClaferMap' (c0_Alice_match) @? ("Improper nesting for " ++ show c0_Alice)
                 (False, False, True) == (isProperRefinement uidIClaferMap' (c0_Alice_match)) @? ("Improper refinement for " ++ show c0_Alice)
diff --git a/test/Suite/SimpleScopeAnalyser.hs b/test/Suite/SimpleScopeAnalyser.hs
--- a/test/Suite/SimpleScopeAnalyser.hs
+++ b/test/Suite/SimpleScopeAnalyser.hs
@@ -28,6 +28,7 @@
 import Language.Clafer.QNameUID
 import Functions
 
+import Data.List (isInfixOf)
 import qualified Data.Map as M
 
 import Test.Tasty
@@ -75,38 +76,38 @@
             ]
 
 expectedScopesSet :: M.Map UID Integer
-expectedScopesSet = M.fromList $ [ ("c0_a", 0)
-                            --   , ("c0_b", 1)  -- uses global scope
-                            --   , ("c0_c", 1)  -- uses global scope
-                            --   , ("c0_d", 1)  -- uses global scope
-                            --   , ("c0_e", 1)  -- uses global scope
-                                 , ("c0_f", 4)
-                                 , ("c0_g", 3)
-                                 , ("c0_gs", 2)
-                                 , ("c0_H", 22)
-                                 , ("c0_i", 22)
-                                 , ("c0_j", 22)
-                                 , ("c0_k", 44)
-                                 , ("c0_Hs", 16)
-                                 , ("c0_H1", 2)
-                                 , ("c0_H12", 4)
-                                 , ("c0_H2", 4)
-                                 , ("c0_H3", 2)
-                                 , ("c0_H4", 5)
-                                 , ("c0_Hs2", 16)
-                                 , ("c0_Hs3", 8)
-                                 , ("c0_l", 8)
-                                 , ("c0_FF", 5)
-                                 , ("c0_f1", 5)
-                                 , ("c0_m", 0)
-                                 , ("c0_i1", 4)
-                            --   , ("c0_i2", 1) -- uses global scope
-                            --   , ("c0_i3", 1) -- uses global scope
-                            --   , ("c0_i4", 1) -- uses global scope
-                                 , ("c0_s1", 2)
-                            --   , ("c0_s2", 1) -- uses global scope
-                            --   , ("c0_s3", 1) -- uses global scope
-                            --   , ("c0_s4", 1) -- uses global scope
+expectedScopesSet = M.fromList $ [ ("a", 0)
+                            --   , ("b", 1)  -- uses global scope
+                            --   , ("c", 1)  -- uses global scope
+                            --   , ("d", 1)  -- uses global scope
+                            --   , ("e", 1)  -- uses global scope
+                                 , ("f", 4)
+                                 , ("g", 3)
+                                 , ("gs", 2)
+                                 , ("H", 22)
+                                 , ("i", 22)
+                                 , ("j", 22)
+                                 , ("k", 44)
+                                 , ("Hs", 22)
+                                 , ("H1", 2)
+                                 , ("H12", 4)
+                                 , ("H2", 4)
+                                 , ("H3", 2)
+                                 , ("H4", 5)
+                                 , ("Hs2", 22)
+                                 , ("Hs3", 8)
+                                 , ("l", 8)
+                                 , ("FF", 5)
+                                 , ("f1", 5)
+                                 , ("m", 0)
+                                 , ("i1", 4)
+                            --   , ("i2", 1) -- uses global scope
+                            --   , ("i3", 1) -- uses global scope
+                            --   , ("i4", 1) -- uses global scope
+                                 , ("s1", 2)
+                            --   , ("s2", 1) -- uses global scope
+                            --   , ("s3", 1) -- uses global scope
+                            --   , ("s4", 1) -- uses global scope
                                  ]
 
 
@@ -141,6 +142,48 @@
         "Computed scopes different from expected:\n" ++ (unlines $ M.foldl (\acc v -> v:acc) [] differences)
 
 
+-- The lower bound of a group cardinality is covered: four C with at least 2 Items each,
+-- and two D with at least 3 of their at most 2 Ys or of their Zs.
+case_ScopeFromGroupCardinality :: Assertion
+case_ScopeFromGroupCardinality = do
+    let
+        groupModel = unlines
+            [ "abstract 2..3 A"
+            , "    Item *"
+            , "C : A 4"
+            , "3..4 D 2"
+            , "    Y 0..2"
+            , "    Z *"
+            ]
+        (Right compilerResultMap) = compileOneFragment defaultClaferArgs groupModel
+        (Just compilerResult) = M.lookup Alloy compilerResultMap
+        computedScopes = M.fromList $ scopesList compilerResult
+    M.lookup "Item" computedScopes @?= Just 8
+    M.lookup "Y" computedScopes @?= Just 4
+    M.lookup "Z" computedScopes @?= Just 6
+
+-- A reference with an unbounded multiplicity may point to all 20 B in each of the 6 A, so its scope is
+-- 120, above 100: the statistics warn and suggest an upper bound. With the upper bound 3, it is 18.
+case_LargeReferenceScopeWarning :: Assertion
+case_LargeReferenceScopeWarning = do
+    let
+        refsModel card' = unlines
+            [ "abstract B"
+            , "B1 : B 20"
+            , "A 6"
+            , "    refs -> B " ++ card'
+            ]
+        statisticsOf m = let
+            (Right compilerResultMap) = compileOneFragment defaultClaferArgs m
+            (Just compilerResult) = M.lookup Alloy compilerResultMap
+          in statistics compilerResult
+        warning = "the scope of refs -> B 0..* is 120, since refs may point to all 20 B in each of its parents."
+    (warning `isInfixOf` statisticsOf (refsModel "*")) @?
+        "No large scope warning in:\n" ++ statisticsOf (refsModel "*")
+    ("refs -> B 0..10" `isInfixOf` statisticsOf (refsModel "*")) @? "No upper bound suggested"
+    (not $ "Warning" `isInfixOf` statisticsOf (refsModel "0..3")) @?
+        "Unexpected warning in:\n" ++ statisticsOf (refsModel "0..3")
+
 case_ReadScopesJSON :: Assertion
 case_ReadScopesJSON = do
     let
@@ -161,3 +204,32 @@
 
     (M.size differences) == 0 @?
         "Parsed scopes different from original:\n" ++ (unlines $ M.foldl (\acc v -> v:acc) [] differences)
+
+-- | chocosolver's scope files (ScopeFile) name clafers by their UIDs and also give the default scope
+-- | and the ranges: the clafer scopes are read, by UID or by name, and the other entries are skipped.
+case_ReadChocoScopesJSON :: Assertion
+case_ReadChocoScopesJSON = do
+    let
+        (Right compilerResultMap) = compileOneFragment defaultClaferArgs model
+        (Just compilerResult) = M.lookup Alloy compilerResultMap
+        Just (iModule, _, _) = cIr $ claferEnv compilerResult
+        qNameMaps = deriveQNameMaps iModule
+        scopesInJSON = unlines
+            [ "["
+            , "{\"lpqName\": \"b\", \"scope\": 2},"
+            , "{\"lpqName\": \"H::k\", \"scope\": 5},"
+            , "{\"defaultScope\": 1},"
+            , "{\"int\": [-8, 7]},"
+            , "{\"decimal\": [-2.5, 2.5]}"
+            , "]" ]
+    M.fromList (parseJSONScopes qNameMaps scopesInJSON) @?= M.fromList [ ("b", 2), ("k", 5) ]
+
+-- | The least-partially-qualified name of the only clafer of a model is its name; the search for it
+-- | did not end (clafer --meta-data hung on such a model).
+case_LpqNameOfOnlyClafer :: Assertion
+case_LpqNameOfOnlyClafer = do
+    let
+        (Right compilerResultMap) = compileOneFragment defaultClaferArgs "x\n"
+        (Just compilerResult) = M.lookup Alloy compilerResultMap
+        Just (iModule, _, _) = cIr $ claferEnv compilerResult
+    getLPQName (deriveQNameMaps iModule) "x" @?= Just "x"
diff --git a/test/Suite/TypeSystem.hs b/test/Suite/TypeSystem.hs
--- a/test/Suite/TypeSystem.hs
+++ b/test/Suite/TypeSystem.hs
@@ -31,8 +31,8 @@
 import Functions
 
 import qualified Data.Map as M
+import Data.List (isInfixOf)
 import Data.Maybe (isJust)
-import Data.StringMap
 import Test.Tasty
 import Test.Tasty.HUnit
 import Test.Tasty.TH
@@ -42,11 +42,11 @@
 
 model :: String
 model = unlines
-    [ "abstract A"             -- c0_A
-    , "    abstract as -> A *" -- c0_as
-    , "abstract B : A"         -- c0_B
-    , "    as : as -> B *"     -- c1_as
-    , "b : B"                  -- c0_b
+    [ "abstract A"             -- A
+    , "    abstract as -> A *" -- A__as
+    , "abstract B : A"         -- B
+    , "    as : as -> B *"     -- B__as
+    , "b : B"                  -- b
     , "    [ as = b ]"
     , "    [ as.ref = b ]"
     ]
@@ -58,26 +58,26 @@
     Nothing -> assertFailure "No Alloy result in the result map"
     Just compilerResult ->
       let
-        um' :: StringMap IClafer
+        um' :: M.Map String IClafer
         um' = uidIClaferMap $ claferEnv compilerResult
 
         root_TClafer = getTClaferByUID um' "root"
         clafer_TClafer = getTClaferByUID um' "clafer"
-        c0_A_TClafer = getTClaferByUID um' "c0_A"
-        c0_A_TClaferR = Just $ TClafer [ "c0_A" ]
-        c0_A_TMap = getDrefTMapByUID um' "c0_A"
-        c0_as_TMap = getDrefTMapByUID um' "c0_as"
-        c0_as_TMapR = Just (TMap {_so = TClafer {_hi = ["c0_as"]}, _ta = TClafer {_hi = ["c0_A"]}})
-        c0_B_TClafer = getTClaferByUID um' "c0_B"
-        c0_B_TClaferR = Just $ TClafer [ "c0_B", "c0_A" ]
-        c1_as_TClafer = getTClaferByUID um' "c1_as"
-        c1_as_TClaferR = Just $ TClafer [ "c1_as", "c0_as" ]
-        c1_as_TMap = getDrefTMapByUID um' "c1_as"
-        c1_as_TMapR = Just (TMap {_so = TClafer {_hi = ["c1_as","c0_as"]}, _ta = TClafer {_hi = [ "c0_B", "c0_A" ]}})
-        c0_b_TClafer = getTClaferByUID um' "c0_b"
-        c0_b_TClaferR = Just $ TClafer [ "c0_b", "c0_B", "c0_A" ]
+        c0_A_TClafer = getTClaferByUID um' "A"
+        c0_A_TClaferR = Just $ TClafer [ "A" ]
+        c0_A_TMap = getDrefTMapByUID um' "A"
+        c0_as_TMap = getDrefTMapByUID um' "A__as"
+        c0_as_TMapR = Just (TMap {_so = TClafer {_hi = ["A__as"]}, _ta = TClafer {_hi = ["A"]}})
+        c0_B_TClafer = getTClaferByUID um' "B"
+        c0_B_TClaferR = Just $ TClafer [ "B", "A" ]
+        c1_as_TClafer = getTClaferByUID um' "B__as"
+        c1_as_TClaferR = Just $ TClafer [ "B__as", "A__as" ]
+        c1_as_TMap = getDrefTMapByUID um' "B__as"
+        c1_as_TMapR = Just (TMap {_so = TClafer {_hi = ["B__as","A__as"]}, _ta = TClafer {_hi = [ "B", "A" ]}})
+        c0_b_TClafer = getTClaferByUID um' "b"
+        c0_b_TClaferR = Just $ TClafer [ "b", "B", "A" ]
       in do
-        (isJust $ findIClafer um' "c0_A")    @? ("Clafer c0_A not found" ++ show um')
+        (isJust $ findIClafer um' "A")    @? ("Clafer c0_A not found" ++ show um')
         root_TClafer == Just rootTClafer     @? ("Incorrect class type for 'root':\ngot        '" ++ show root_TClafer ++ "'\ninstead of '" ++ show rootTClafer ++ "'")
         clafer_TClafer == Just claferTClafer @? ("Incorrect class type for 'clafer':\ngot        '" ++ show clafer_TClafer ++ "'\ninstead of '" ++ show claferTClafer ++ "'")
         c0_A_TClafer == c0_A_TClaferR        @? ("Incorrect class type for 'c0_A':\ngot        '" ++ show c0_A_TClafer ++ "'\ninstead of '" ++ show c0_A_TClaferR ++ "'")
@@ -87,3 +87,56 @@
         c1_as_TClafer == c1_as_TClaferR      @? ("Incorrect class type for 'c1_as':\ngot        '" ++ show c1_as_TClafer ++ "'\ninstead of '" ++ show c1_as_TClaferR ++ "'")
         c1_as_TMap == c1_as_TMapR            @? ("Incorrect map type for 'c1_as':\ngot        '" ++ show c1_as_TMap ++ "'\ninstead of '" ++ show c1_as_TMapR ++ "'")
         c0_b_TClafer == c0_b_TClaferR        @? ("Incorrect class type for 'c0_b':\ngot        '" ++ show c0_b_TClafer ++ "'\ninstead of '" ++ show c0_b_TClaferR ++ "'")
+
+-- An expression compared with, subtracted from or intersected with itself is correct, but probably not
+-- what was meant: the model compiles, and the statistics warn about it at its position.
+case_RedundantExpressionWarning :: Assertion
+case_RedundantExpressionWarning = case compileOneFragment defaultClaferArgs redundantModel of
+  Left errors -> assertFailure $ show errors
+  Right compilerResultMap -> case M.lookup Alloy compilerResultMap of
+    Nothing -> assertFailure "No Alloy result in the result map"
+    Just compilerResult -> do
+      let stats = statistics compilerResult
+          expected =
+            [ ":4:3: '=' is redundant because the two subexpressions are always equivalent, so it is always true."
+            , ":5:3: '!=' is redundant because the two subexpressions are always equivalent, so it is always false."
+            , ":6:7: '--' is redundant because the two subexpressions are always equivalent, so it is always empty."
+            , ":7:3: '**' is redundant because the two subexpressions are always equivalent, so it is the same as either subexpression."
+            , ":8:10: '=' is redundant because the two subexpressions are always equivalent, so it is always true."
+            ]
+      mapM_ (\w -> (w `isInfixOf` stats) @? ("No warning " ++ show w ++ " in:\n" ++ stats)) expected
+      length (filter ("Warning" `isInfixOf`) $ lines stats) @?= length expected
+  where
+    redundantModel = unlines
+      [ "a ?"
+      , "b ?"
+      , ""
+      , "[ a = a ]"
+      , "[ a != a || some b ]"
+      , "[ no (b -- b) ]"
+      , "[ b ** b = b ]"
+      , "assert [ noclafer = noclafer ]"
+      ]
+
+-- A navigation from noclafer is empty, whatever it navigates to, even to a name that does not exist:
+-- the model compiles, the navigation is noclafer, and the statistics warn about it at its position.
+case_NoClaferNavigationWarning :: Assertion
+case_NoClaferNavigationWarning = case compileOneFragment defaultClaferArgs navModel of
+  Left errors -> assertFailure $ show errors
+  Right compilerResultMap -> case M.lookup Alloy compilerResultMap of
+    Nothing -> assertFailure "No Alloy result in the result map"
+    Just compilerResult -> do
+      let stats = statistics compilerResult
+          warning l c = ":" ++ show (l :: Int) ++ ":" ++ show (c :: Int) ++ ": a navigation from \x27noclafer\x27 is redundant, since it is always empty."
+          expected = [warning 3 6, warning 4 4, warning 5 6]
+      mapM_ (\w -> (w `isInfixOf` stats) @? ("No warning " ++ show w ++ " in:\n" ++ stats)) expected
+      length (filter ("Warning" `isInfixOf`) $ lines stats) @?= length expected
+      ("{ no none }" `isInfixOf` outputCode compilerResult) @? ("No navigation replaced with none in:\n" ++ outputCode compilerResult)
+  where
+    navModel = unlines
+      [ "c ?"
+      , "    d ?"
+      , "[ no noclafer.d ]"
+      , "[ #noclafer.d.parent = 0 ]"
+      , "[ no noclafer.dref.unknown ]"
+      ]
diff --git a/test/model-tests.hs b/test/model-tests.hs
new file mode 100644
--- /dev/null
+++ b/test/model-tests.hs
@@ -0,0 +1,32 @@
+{-
+ Copyright (C) 2013-2017 Luke Brown, Michal Antkiewicz <http://gsd.uwaterloo.ca>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-}
+-- Compiles the models in test/positive and test/negative. Built only with the
+-- model-tests flag, in a checkout of the repository (the models are not packaged).
+import Suite.Positive
+import Suite.Negative
+import Test.Tasty
+
+main :: IO ()
+main = defaultMain $ testGroup "Model tests"
+    [ tg_Test_Suite_Positive
+    , tg_Test_Suite_Negative
+    ]
diff --git a/test/test-suite.hs b/test/test-suite.hs
--- a/test/test-suite.hs
+++ b/test/test-suite.hs
@@ -21,16 +21,26 @@
  SOFTWARE.
 -}
 import Control.Lens
+import Control.Monad (forM_)
+import qualified Data.Aeson as Aeson
 import Data.Data.Lens
 import Data.List
 import qualified Data.Map as Map
 import Data.Maybe
+import Data.String (fromString)
 import Language.Clafer
+import Language.Clafer.Import
 import Language.Clafer.QNameUID
+import Language.Clafer.ClaferArgs (ClaferMode (Clafer))
+import Language.Clafer.Front.AbsClafer (Span (..), noSpan)
 import Language.Clafer.Intermediate.Intclafer
+import Language.ClaferT (CErr (..), ErrPos (..), modifyEnv)
+import Language.Clafer.Generator.Html (highlightErrorsIn)
 
-import Suite.Positive
-import Suite.Negative
+import Network.URI (parseURI)
+import Network.Socket (tupleToHostAddress)
+import System.Directory (createDirectoryIfMissing, createDirectoryLink, createFileLink, getTemporaryDirectory, removeDirectoryRecursive, removePathForcibly)
+
 import Suite.SimpleScopeAnalyser
 import Suite.Redefinition
 import Suite.TypeSystem
@@ -47,25 +57,25 @@
     [ tg_Test_Suite_TypeSystem
     , tg_Test_Suite_Redefinition
     , tg_Main_Test_Suite
-    , tg_Test_Suite_Positive
-    , tg_Test_Suite_Negative
     , tg_Test_Suite_SimpleScopeAnalyser
     ]
 
 {-
-a            // ::a -> c0_a
-    b        // ::a::b -> c0_b
-b            // ::b -> c1_b
-c            // ::c -> c0_c
-    d        // ::c::d -> c0_d
-         b   // ::c::d::b -> c2_b
-d            // ::d -> c1_d
-    b        // ::d::b -> c3_b
+The UID of each clafer is its least-partially-qualified name:
 
-"b" -> "c0_b", "c1_b", "c2_b", "c3_b"
-"d::b" -> "c2_b", "c3_b"
-"c::d" -> "c0_d"
-"d" -> "c0_d", "c1_d"
+a            // root__a, ::a -> a
+    b        // root__a__b, ::a::b -> a__b
+b            // root__b, ::b -> root__b
+c            // root__c, ::c -> c
+    d        // root__c__d, ::c::d -> c__d
+         b   // root__c__d__b, ::c::d::b -> c__d__b
+d            // root__d, ::d -> root__d
+    b        // root__d__b, ::d::b -> root__d__b
+
+"b" -> "a__b", "root__b", "c__d__b", "root__d__b"
+"d::b", "d__b" -> "c__d__b", "root__d__b"
+"c::d", "c__d" -> "c__d"
+"d" -> "c__d", "root__d"
 "x" -> []
 
 a\n    b\nb\nc\n    d\n         b\nd\n    b
@@ -78,21 +88,40 @@
     let
         (Just (iModule, _, _)) = cIr $ claferEnv $ fromJust $ Map.lookup Alloy $ fromRight $ compileOneFragment defaultClaferArgs model
         qNameMaps = deriveQNameMaps iModule
-    [ "c0_a" ] == getUIDs qNameMaps "::a"  @? "UID for `::a` different from `c0_a`"
-    [ "c0_b" ] == getUIDs qNameMaps "::a::b"  @? "UID for `::a::b` different from `c0_b`"
-    [ "c1_b" ] == getUIDs qNameMaps "::b"  @? "UID for `::b` different from `c1_b`"
-    [ "c0_c" ] == getUIDs qNameMaps "::c"  @? "UID for `::c` different from `c0_c`"
-    [ "c0_d" ] == getUIDs qNameMaps "::c::d"  @? "UID for `::c::d` different from `c0_d`"
-    [ "c0_d" ] == getUIDs qNameMaps "c::d"  @? "UID for `c::d` different from `c0_d`"
-    [ "c2_b" ] == getUIDs qNameMaps "::c::d::b"  @? "UID for `::c::d::b` different from `c2_b`"
-    [ "c1_d" ] == getUIDs qNameMaps "::d"  @? "UID for `::d` different from `c1_d`"
-    [ "c3_b" ] == getUIDs qNameMaps "::d::b"  @? "UID for `::d::b` different from `c3_d`"
-    null ([ "c0_b", "c1_b", "c2_b", "c3_b" ] \\ (getUIDs qNameMaps "b" )) @? "UIDs for `b` different from `c0_b`, `c1_b`, `c2_b`, `c3_b` "
-    null ([ "c2_b", "c3_b" ] \\ (getUIDs qNameMaps "d::b" )) @? "UIDs for `d::b` different from `c2_b`, `c3_b` "
-    null ([ "c0_d", "c1_d" ] \\ (getUIDs qNameMaps "d" )) @? "UIDs for `d` different from `c0_d`, `c1_d` "
+    [ "a" ] == getUIDs qNameMaps "::a"  @? "UID for `::a` different from `a`"
+    [ "a__b" ] == getUIDs qNameMaps "::a::b"  @? "UID for `::a::b` different from `a__b`"
+    [ "root__b" ] == getUIDs qNameMaps "::b"  @? "UID for `::b` different from `root__b`"
+    [ "c" ] == getUIDs qNameMaps "::c"  @? "UID for `::c` different from `c`"
+    [ "c__d" ] == getUIDs qNameMaps "::c::d"  @? "UID for `::c::d` different from `c__d`"
+    [ "c__d" ] == getUIDs qNameMaps "c::d"  @? "UID for `c::d` different from `c__d`"
+    [ "c__d__b" ] == getUIDs qNameMaps "::c::d::b"  @? "UID for `::c::d::b` different from `c__d__b`"
+    [ "root__d" ] == getUIDs qNameMaps "::d"  @? "UID for `::d` different from `root__d`"
+    [ "root__d__b" ] == getUIDs qNameMaps "::d::b"  @? "UID for `::d::b` different from `root__d__b`"
+    null ([ "a__b", "root__b", "c__d__b", "root__d__b" ] \\ (getUIDs qNameMaps "b" )) @? "UIDs for `b` different from `a__b`, `root__b`, `c__d__b`, `root__d__b`"
+    null ([ "c__d__b", "root__d__b" ] \\ (getUIDs qNameMaps "d::b" )) @? "UIDs for `d::b` different from `c__d__b`, `root__d__b`"
+    null ([ "c__d", "root__d" ] \\ (getUIDs qNameMaps "d" )) @? "UIDs for `d` different from `c__d`, `root__d`"
+    -- the same with __, the separator of the UIDs, and root__ for ::
+    [ "a" ] == getUIDs qNameMaps "root__a"  @? "UID for `root__a` different from `a`"
+    [ "root__b" ] == getUIDs qNameMaps "root__b"  @? "UID for `root__b` different from `root__b`"
+    [ "c__d" ] == getUIDs qNameMaps "c__d"  @? "UID for `c__d` different from `c__d`"
+    [ "c__d__b" ] == getUIDs qNameMaps "root__c__d__b"  @? "UID for `root__c__d__b` different from `c__d__b`"
+    null ([ "c__d__b", "root__d__b" ] \\ (getUIDs qNameMaps "d__b" )) @? "UIDs for `d__b` different from `c__d__b`, `root__d__b`"
+    Just "root__c__d__b" == getFQName qNameMaps "c__d__b"  @? "FQ name of `c__d__b`: " ++ show (getFQName qNameMaps "c__d__b")
+    Just "root__d" == getLPQName qNameMaps "root__d"  @? "LPQ name of `root__d`: " ++ show (getLPQName qNameMaps "root__d")
     null (getUIDs qNameMaps "x") @? "UID for `x` different from []"
     null (getUIDs qNameMaps "::x") @? "UID for `::x` different from []"
 
+-- | A name that is a prefix of another name does not match it
+case_QNamesWholeNames :: Assertion
+case_QNamesWholeNames = do
+    let
+        (Just (iModule, _, _)) = cIr $ claferEnv $ fromJust $ Map.lookup Alloy $ fromRight $ compileOneFragment defaultClaferArgs "light\n    yellow\n    yellow_on\n"
+        qNameMaps = deriveQNameMaps iModule
+    [ "yellow" ] == getUIDs qNameMaps "yellow"  @? "UIDs for `yellow`: " ++ show (getUIDs qNameMaps "yellow")
+    [ "yellow" ] == getUIDs qNameMaps "light::yellow"  @? "UIDs for `light::yellow`: " ++ show (getUIDs qNameMaps "light::yellow")
+    [ "yellow" ] == getUIDs qNameMaps "light__yellow"  @? "UIDs for `light__yellow`: " ++ show (getUIDs qNameMaps "light__yellow")
+    Just "yellow" == getLPQName qNameMaps "yellow"  @? "LPQ name of `yellow`: " ++ show (getLPQName qNameMaps "yellow")
+
 case_AllClafersGenerics :: Assertion
 case_AllClafersGenerics = do
     let
@@ -100,4 +129,612 @@
         allClafers :: [ IClafer ]
         allClafers = universeOn biplate iModule
         allClafersUids = map _uid allClafers
-    allClafersUids == [ "c0_a", "c0_b", "c1_b", "c0_c", "c0_d", "c2_b", "c1_d", "c3_b"] @? "All clafers\n" ++ show allClafersUids
+    allClafersUids == [ "a", "a__b", "root__b", "c", "c__d", "c__d__b", "root__d", "root__d__b"] @? "All clafers\n" ++ show allClafersUids
+
+{-
+Comments are shown as written in the HTML output: their markup is escaped, and
+a //# comment, which becomes an HTML comment, cannot end it early with "--".
+-}
+commentsModel :: String
+commentsModel = "// standalone <b>tags</b> & \"quotes\"\nA\n    B // inline <i>x</i>\n//# note -- with -->\n"
+
+case_HtmlCommentsEscaped :: Assertion
+case_HtmlCommentsEscaped = do
+    let
+        html = outputCode $ fromJust $ Map.lookup Html $ fromRight $ compileOneFragment defaultClaferArgs{mode = [Html], add_comments = True} commentsModel
+    ("// standalone &lt;b&gt;tags&lt;/b&gt; &amp; &quot;quotes&quot;" `isInfixOf` html) @? "The standalone comment is not escaped\n" ++ html
+    ("// inline &lt;i&gt;x&lt;/i&gt;" `isInfixOf` html) @? "The inline comment is not escaped\n" ++ html
+    not ("<b>" `isInfixOf` html || "<i>" `isInfixOf` html) @? "Markup from a comment is in the HTML\n" ++ html
+    ("<!-- # note - - with - -> /-->" `isInfixOf` html) @? "The //# comment contains \"--\"\n" ++ html
+
+{-
+Clafer names may contain apostrophes, but the UIDs are identifiers, in Clafer and in
+the Alloy and Choco (JavaScript) outputs: an apostrophe becomes "_prime". same'
+and same_prime still get different UIDs: the one later in the model gets __2.
+-}
+apostropheModel :: String
+apostropheModel = "A\n    same' ?\n    same_prime ?\n    links' -> same' *\n    [ some same' ]\n"
+
+case_ApostrophesNotInUIDs :: Assertion
+case_ApostrophesNotInUIDs = do
+    let
+        results = fromRight $ compileOneFragment defaultClaferArgs{mode = [Alloy, Choco]} apostropheModel
+        alloy = outputCode $ fromJust $ Map.lookup Alloy results
+        choco = outputCode $ fromJust $ Map.lookup Choco results
+        (Just (iModule, _, _)) = cIr $ claferEnv $ fromJust $ Map.lookup Alloy results
+        clafers :: [ IClafer ]
+        clafers = universeOn biplate iModule
+        uidsOf name = [ _uid c | c <- clafers, _ident c == name ]
+    uidsOf "same'" == ["same_prime"] @? "UID of same' is not same_prime: " ++ show (uidsOf "same'")
+    uidsOf "same_prime" == ["same_prime__2"] @? "UID of same_prime is not same_prime__2: " ++ show (uidsOf "same_prime")
+    uidsOf "links'" == ["links_prime"] @? "UID of links' is not links_prime: " ++ show (uidsOf "links'")
+    not ("same'" `isInfixOf` alloy) @? "Alloy: an apostrophe in a UID\n" ++ alloy
+    ("sig same_prime" `isInfixOf` alloy && "sig same_prime__2" `isInfixOf` alloy) @? "Alloy: same' and same_prime are not two signatures\n" ++ alloy
+    not ("same'" `isInfixOf` choco) @? "Choco: an apostrophe in a UID\n" ++ choco
+    ("$same_prime = $A.addChild(\"same_prime\")" `isInfixOf` choco) @? "Choco: same' is not declared as same_prime\n" ++ choco
+
+{-
+The UIDs do not depend on the outputs: a clafer named sig (an Alloy keyword) or show (the
+Alloy output's predicate) keeps its UID, and so does r_x next to x (r_x is the relation of x);
+the Alloy output renames them, and the variables of the Choco output are $ and the UID.
+-}
+alloyNamesModel :: String
+alloyNamesModel = "sig ?\nshow ?\nx\nr_x ?\n[ some sig => some show ]\n"
+
+case_UIDsNotOfTheOutputs :: Assertion
+case_UIDsNotOfTheOutputs = do
+    let
+        results = fromRight $ compileOneFragment defaultClaferArgs{mode = [Alloy, Choco]} alloyNamesModel
+        alloy = outputCode $ fromJust $ Map.lookup Alloy results
+        choco = outputCode $ fromJust $ Map.lookup Choco results
+        (Just (iModule, _, _)) = cIr $ claferEnv $ fromJust $ Map.lookup Alloy results
+        uids = map _uid (universeOn biplate iModule :: [ IClafer ])
+    uids == ["sig", "show", "x", "r_x"] @? "UIDs: " ++ show uids
+    all (`isInfixOf` alloy) ["lone sig sig_1", "lone sig show_1", "one sig x", "lone sig r_x_1", "(some sig_1) => (some show_1)"]
+        @? "Alloy: the clafers are not renamed\n" ++ alloy
+    not ("sig sig\n" `isInfixOf` alloy) @? "Alloy: a signature named sig\n" ++ alloy
+    all (`isInfixOf` choco) ["$sig = Clafer(\"sig\")", "$show = Clafer(\"show\")", "$r_x = Clafer(\"r_x\")"]
+        @? "Choco: the clafers are not declared by their UIDs\n" ++ choco
+
+{-
+The JSON IR has the source positions of the clafers and expressions: lines and
+columns from 1, with an exclusive end; a tab advances to the next column 8k+1.
+-}
+positionsModel :: String
+positionsModel = "A\n  b ?\nC\n\td ?\n[ some b ]\n"
+
+case_JsonPositions :: Assertion
+case_JsonPositions = do
+    let
+        (Just (iModule, _, _)) = cIr $ claferEnv $ fromJust $ Map.lookup Alloy $ fromRight $ compileOneFragment defaultClaferArgs positionsModel
+        clafers :: [ IClafer ]
+        clafers = universeOn biplate iModule
+        posOf name = [ Aeson.toJSON $ _cinPos c | c <- clafers, _ident c == name ]
+        constraintPos = [ Aeson.toJSON $ _inPos e | IEConstraint _ e <- _mDecls iModule ]
+        jsonSpan (l1, c1) (l2, c2) = Aeson.object [ (fromString "start", jsonPos l1 c1), (fromString "end", jsonPos l2 c2) ]
+        jsonPos :: Integer -> Integer -> Aeson.Value
+        jsonPos l c = Aeson.object [ (fromString "line", Aeson.toJSON l), (fromString "column", Aeson.toJSON c) ]
+    posOf "b" == [ jsonSpan (2, 3) (2, 6) ] @? "Position of b: " ++ show (posOf "b")
+    posOf "d" == [ jsonSpan (4, 9) (4, 12) ] @? "Position of d, indented with a tab: " ++ show (posOf "d")
+    constraintPos == [ jsonSpan (5, 3) (5, 9) ] @? "Position of the constraint: " ++ show constraintPos
+    Aeson.toJSON noSpan == Aeson.Null @? "noSpan is not null"
+
+{-
+Comments do not count in the layout: a line which starts with a comment is
+indented as if the comment was not there, at the column where it starts. The
+positions of the clafers are unchanged.
+-}
+commentLayoutModel :: String
+commentLayoutModel = "A\n  /*history*/ xor on\n    normal\n    flashing\n  /*history*/ off\n      // further right\n  B /* trailing */\n/* a block\n   comment */ C\n"
+
+case_CommentsNotInLayout :: Assertion
+case_CommentsNotInLayout = do
+    let
+        (Just (iModule, _, _)) = cIr $ claferEnv $ fromJust $ Map.lookup Alloy $ fromRight $ compileOneFragment defaultClaferArgs commentLayoutModel
+        clafers :: [ IClafer ]
+        clafers = universeOn biplate iModule
+        parentOf name = [ _parentUID c | c <- clafers, _ident c == name ]
+        startOf name = [ (l, c') | c <- clafers, _ident c == name, let Span (Pos l c') _ = _cinPos c ]
+    map parentOf ["on", "normal", "flashing", "off", "B", "C"] == map (:[]) ["A", "on", "on", "A", "A", "root"]
+        @? "Wrong nesting: " ++ show (map parentOf ["on", "normal", "flashing", "off", "B", "C"])
+    startOf "on" == [(2, 15)] @? "Position of on changed: " ++ show (startOf "on")
+
+{-
+A group cardinality whose lower bound the children cannot reach is an error.
+The children include the inherited ones, and the group cardinality may be
+inherited or redefined: myGroup's 2..2 is satisfiable with d and the inherited
+a, b and c. An abstract clafer's group may get its children from subclafers.
+-}
+groupsModel :: String
+groupsModel = "abstract or SuperGroup\n   a ?\n   b ?\n   c ?\n\n2..2 myGroup : SuperGroup\n   d ?\n\nabstract xor Empty\nfilled : Empty\n   e ?\n   f ?\n"
+
+case_UnsatisfiableGroupRejected :: Assertion
+case_UnsatisfiableGroupRejected = do
+    let
+        compiles model' = either (const False) (const True) $ compileOneFragment defaultClaferArgs model'
+        errorsOf model' = either show (const "") $ compileOneFragment defaultClaferArgs model'
+    compiles groupsModel @? "Inherited children are not counted\n" ++ errorsOf groupsModel
+    ("of Mode cannot be satisfied" `isInfixOf` errorsOf "Phone\n   xor Mode\n") @? "xor over no children compiled: " ++ errorsOf "Phone\n   xor Mode\n"
+    ("of bare cannot be satisfied" `isInfixOf` errorsOf (groupsModel ++ "bare : Empty\n")) @? "Inherited xor over no children compiled"
+    ("of tooFew cannot be satisfied" `isInfixOf` errorsOf "3..* tooFew\n   x ?\n   y 0..1\n") @? "3..* over two optional children compiled"
+    compiles "2..* many\n   x *\n" @? "2..* over x * rejected"
+
+{-
+An ambiguous name of a super is not unique, with the paths of the candidates
+(#115); two candidates in the same namespace are a duplicate definition.
+-}
+case_AmbiguousSuperName :: Assertion
+case_AmbiguousSuperName = do
+    let
+        errorsOf model' = either show (const "") $ compileOneFragment defaultClaferArgs model'
+        ambiguous = errorsOf "A\n    abstract T\nB\n    abstract T\nx : T\n"
+        duplicate = errorsOf "abstract T\nabstract T\nx : T\n"
+    all (`isInfixOf` ambiguous) ["clafer \\\"T\\\" is not unique", "A.A__T", "B.B__T"] @? "Wrong error for an ambiguous super: " ++ ambiguous
+    ("cannot be defined because the name should be unique in the same namespace" `isInfixOf` duplicate) @? "Wrong error for a duplicate super: " ++ duplicate
+
+{-
+A group cardinality at the start of a line belongs to the clafer on that line,
+not to the clafer on the line before, which has no cardinality (#117).
+-}
+case_GroupCardinalityOnNextLine :: Assertion
+case_GroupCardinalityOnNextLine = do
+    let
+        (Just (iModule, _, _)) = cIr $ claferEnv $ fromJust $ Map.lookup Alloy $ fromRight $ compileOneFragment defaultClaferArgs "a\n2..3 b\n  c\n  d\nf\n  g\n  1..2 h\n    i\n"
+        clafers :: [ IClafer ]
+        clafers = universeOn biplate iModule
+        cardOf name = [ _card c | c <- clafers, _ident c == name ]
+        gcardOf name = [ _interval <$> _gcard c | c <- clafers, _ident c == name ]
+    map cardOf ["a", "b", "f", "g", "h"] == replicate 5 [Just (1, 1)] @? "Wrong cardinalities: " ++ show (map cardOf ["a", "b", "f", "g", "h"])
+    map gcardOf ["b", "h"] == [[Just (2, 3)], [Just (1, 2)]] @? "Wrong group cardinalities: " ++ show (map gcardOf ["b", "h"])
+    map cardOf ["c", "d", "i"] == replicate 3 [Just (0, 1)] @? "Children not optional: " ++ show (map cardOf ["c", "d", "i"])
+
+{-
+A child without a multiplicity is mandatory under the default group (no group
+cardinality or 0..*) and optional under a keyword group, opt included, also when
+the group is inherited, or under another range. Only keywords set _isKeyword.
+-}
+childDefaultsModel :: String
+childDefaultsModel = "opt Extras\n  sunroof\nabstract opt Options\n  usb\nCar : Options\n  towbar\nxor Engine\n  gas\n0..3 Colours\n  red\nPlain\n  seat\n0..* Free\n  x\n"
+
+case_ChildDefaultsOfGroups :: Assertion
+case_ChildDefaultsOfGroups = do
+    let
+        (Just (iModule, _, _)) = cIr $ claferEnv $ fromJust $ Map.lookup Alloy $ fromRight $ compileOneFragment defaultClaferArgs childDefaultsModel
+        clafers :: [ IClafer ]
+        clafers = universeOn biplate iModule
+        cardOf name = [ _card c | c <- clafers, _ident c == name ]
+        keywordOf name = [ _isKeyword <$> _gcard c | c <- clafers, _ident c == name ]
+        optional' = [ "sunroof", "usb", "towbar", "gas", "red" ]
+        mandatory = [ "seat", "x" ]
+    all (\n -> cardOf n == [Just (0, 1)]) optional' @? "Not optional: " ++ show (map cardOf optional')
+    all (\n -> cardOf n == [Just (1, 1)]) mandatory @? "Not mandatory: " ++ show (map cardOf mandatory)
+    map keywordOf ["Extras", "Car", "Engine", "Colours", "Free"] == map (\k -> [Just k]) [True, True, True, False, False]
+        @? "Wrong _isKeyword: " ++ show (map keywordOf ["Extras", "Car", "Engine", "Colours", "Free"])
+
+{-
+A model imports other files with --import, in its //# OPTIONS or on the command
+line: the imports are followed transitively, each file is included once, before
+the files importing it, and a path in //# OPTIONS is relative to its file. The
+options of all files are combined.
+-}
+importFiles :: [(FilePath, String)]
+importFiles =
+  [ ("lib/base.cfr", "//# OPTIONS --maxint=63\nabstract Base\n  x -> integer\n")
+  , ("lib/mid.cfr",  "//# OPTIONS --import=base.cfr --maxint=127 --minint=-5 -k\nabstract Mid : Base\n")
+  , ("sys.cfr",      "//# OPTIONS --import=lib/mid.cfr --import=lib/base.cfr -m choco\nSys : Mid\n  [ x = 100 ]\n")
+  , ("cli.cfr",      "Gadget : Base\n")
+  , ("bad.cfr",      "//# OPTIONS --import=lib/base.cfr\nBad : Base\n  [ y = 1 ]\n")
+  , ("c1.cfr",       "//# OPTIONS --import=c2.cfr\nA\n")
+  , ("c2.cfr",       "//# OPTIONS --import=c1.cfr\nB\n")
+  , ("missing.cfr",  "//# OPTIONS --import=nothere.cfr\nA\n")
+  , ("lib/run.cfr",  "//# OPTIONS -v\nabstract R\n")
+  , ("run.cfr",      "//# OPTIONS --import=lib/run.cfr\nr : R\n")
+  , ("lib/nl.cfr",   "//# OPTIONS --nl\nabstract N\n")
+  , ("nl.cfr",       "//# OPTIONS --import=lib/nl.cfr\nn : N\n")
+  ]
+
+case_Imports :: Assertion
+case_Imports = do
+    tmp <- getTemporaryDirectory
+    let dir = tmp ++ "/clafer-test-imports"
+        path name = dir ++ "/" ++ name
+        readModel' name args' = readModel args'{file = path name}
+    createDirectoryIfMissing True (dir ++ "/lib")
+    mapM_ (\(name, text) -> writeFile (path name) text) importFiles
+    -- a chain and a diamond: base once, before mid, before sys; the options combined
+    Right (args', files) <- readModel' "sys.cfr" claferDefaults
+    map modelFilePath files == map path ["lib/base.cfr", "lib/mid.cfr", "sys.cfr"] @? "Files: " ++ show (map modelFilePath files)
+    (maxint args', minint args', mode args', keep_unused args') == (Just 127, Just (-5), [Choco], True)
+        @? "Combined options: " ++ show (maxint args', minint args', mode args', keep_unused args')
+    let results = fromRight $ compileOneFragment args'{mode = [Choco]} $ modelText files
+    ("intRange(-5, 127);" `isInfixOf` outputCode (fromJust $ Map.lookup Choco results)) @? "No combined integer range"
+    -- the command line's arguments take precedence, and its imports are relative to the current folder
+    Right (cliArgs, cliFiles) <- readModel' "cli.cfr" claferDefaults{imports = [path "lib/base.cfr"], maxint = Just 7}
+    (map modelFilePath cliFiles, maxint cliArgs) == (map path ["lib/base.cfr", "cli.cfr"], Just 7)
+        @? "Command line import: " ++ show (map modelFilePath cliFiles, maxint cliArgs)
+    -- an error in a file is reported at its line in that file
+    Right (_, badFiles) <- readModel' "bad.cfr" claferDefaults
+    case compileOneFragment defaultClaferArgs $ modelText badFiles of
+      Left [SemanticErr ErrPos{modelPos = Pos l c} _] ->
+        (modelPosition badFiles l, c) == ((path "bad.cfr", 3), 5) @? "Error position: " ++ show (modelPosition badFiles l, c)
+      result -> assertFailure $ "bad.cfr: " ++ either show (const "compiled") result
+    -- cycles, missing files, options of the compilation in an imported file, different layouts
+    let failsWith name expected = do
+          result <- readModel' name claferDefaults
+          case result of
+            Left message -> (expected `isInfixOf` message) @? name ++ ": " ++ message
+            Right _      -> assertFailure $ name ++ " was read"
+    failsWith "c1.cfr" "Import cycle: "
+    failsWith "missing.cfr" "nothere.cfr does not exist"
+    failsWith "run.cfr" "the option -v can only be given on the command line"
+    failsWith "nl.cfr" "The option --nl must be the same in all files"
+    removeDirectoryRecursive dir
+
+{-
+The spans of the JSON IR and the HTML output give the files of the model: each span
+names its file, with the lines in that file, and the HTML shows each file under its
+name, also the errors' positions.
+-}
+filesModel :: [ModelFile]
+filesModel =
+  [ ModelFile "lib.cfr" "abstract L\n  x ?\n"
+  , ModelFile "m.cfr" "// the model\nA : L\n  [ x ]\n" ]
+
+-- | Compiles the files of a model, as the compiler does.
+compileFiles :: ClaferArgs -> [ModelFile] -> Either [ClaferErr] (Map.Map ClaferMode CompilerResult)
+compileFiles args' files = runClafer args' $ do
+    addModuleFragment $ modelText files
+    modifyEnv $ \env -> env{inputFiles = files}
+    parse
+    iModule <- desugar Nothing
+    compile iModule
+    generate
+
+case_SpansInFiles :: Assertion
+case_SpansInFiles = do
+    let results = fromRight $ compileFiles defaultClaferArgs{mode = [JSON, Html]} filesModel
+        output m = outputCode $ fromJust $ Map.lookup m results
+        Just json = Aeson.decode (fromString $ output JSON) :: Maybe Aeson.Value
+        -- the files and start lines of the spans
+        spans :: Aeson.Value -> [(String, Integer)]
+        spans (Aeson.Object o) = case (Aeson.fromJSON (Aeson.Object o)) of
+          Aeson.Success (SpanInFile f l) -> [(f, l)]
+          _ -> concatMap spans (toListOf folded o)
+        spans (Aeson.Array a) = concatMap spans (toListOf folded a)
+        spans _ = []
+        html = output Html
+    (sort $ nub $ spans json) == [("lib.cfr", 1), ("lib.cfr", 2), ("m.cfr", 2), ("m.cfr", 3)]
+        @? "Spans: " ++ show (sort $ nub $ spans json)
+    let headers = [ i | (i, l) <- zip [0 :: Int ..] (lines html), "<div class=\"file\">" `isPrefixOf` l ]
+    (map (lines html !!) headers == ["<div class=\"file\">lib.cfr</div>", "<div class=\"file\">m.cfr</div>"])
+        @? "File headers: " ++ show (map (lines html !!) headers)
+    -- an error in a file: the HTML error output gives its file and line
+    let bad = [ head filesModel, ModelFile "m.cfr" "A : L\n  [ y ]\n" ]
+    case compileFiles defaultClaferArgs{mode = [Html]} bad of
+      Left errs -> ("Compiling failed at m.cfr:2:5..." `isInfixOf` highlightErrorsIn bad (modelText bad) errs)
+                     @? "Error HTML: " ++ highlightErrorsIn bad (modelText bad) errs
+      Right _ -> assertFailure "m.cfr compiled"
+
+-- | A span in a file, as in the JSON IR: its file and start line.
+data SpanInFile = SpanInFile String Integer
+
+instance Aeson.FromJSON SpanInFile where
+  parseJSON = Aeson.withObject "span" $ \o -> do
+    f <- o Aeson..: fromString "file"
+    start <- o Aeson..: fromString "start"
+    l <- start Aeson..: fromString "line"
+    return $ SpanInFile f l
+
+{-
+A model which may come from anyone (e.g., in a web tool) is compiled with --import-root: a
+local import must be inside one of the roots, after resolving .. and symbolic links. The
+options that run tools or restrict the imports cannot be set in //# OPTIONS.
+-}
+case_ImportRestrictions :: Assertion
+case_ImportRestrictions = do
+    tmp <- getTemporaryDirectory
+    let dir = tmp ++ "/clafer-test-roots"
+        path name = dir ++ "/" ++ name
+    removePathForcibly dir  -- left by a failed run
+    createDirectoryIfMissing True (path "session")
+    createDirectoryIfMissing True (path "Examples")
+    writeFile (path "Examples/lib.cfr") "abstract Lib\n"
+    writeFile (path "outside.cfr") "abstract Outside\n"
+    createDirectoryLink (path "Examples") (path "session/Examples")
+    createFileLink (path "outside.cfr") (path "session/escape.cfr")
+    let compileWith imports' = do
+          writeFile (path "session/model.cfr") $ "//# OPTIONS " ++ imports' ++ "\nA\n"
+          readModel claferDefaults{file = path "session/model.cfr", import_root = [path "session", path "Examples"]}
+        allowed imports' = compileWith imports' >>= \r -> either (\m -> assertFailure $ imports' ++ ": " ++ m) (const $ return ()) r
+        refused imports' expected = compileWith imports' >>= \r -> case r of
+          Left message -> (expected `isInfixOf` message) @? imports' ++ ": " ++ message
+          Right _      -> assertFailure $ imports' ++ " was read"
+        outside = "is outside the folders from which files can be imported"
+    allowed "--import=Examples/lib.cfr"
+    refused "--import=../outside.cfr" outside
+    refused ("--import=" ++ path "outside.cfr") outside
+    refused "--import=escape.cfr" outside
+    refused "--import=../nothere.cfr" outside
+    refused "--import=nothere.cfr" "does not exist"
+    refused "--import=../../../etc/hostname" "etc/hostname is not a .cfr file"
+    refused "--import=http://example.org/index.php?x=.cfr" "is not a .cfr file"
+    refused "-v" "the option -v can only be given on the command line"
+    refused "--tooldir=/tmp --import-root=/" "the options --tooldir, --import-root can only be given on the command line"
+    refused "--public-imports --import-base=http://example.org/" "the options --public-imports, --import-base can only be given"
+    removeDirectoryRecursive dir
+
+case_PublicAddresses :: Assertion
+case_PublicAddresses = do
+    let public = isPublicAddress . tupleToHostAddress
+    map public [(8, 8, 8, 8), (140, 82, 112, 3), (172, 32, 0, 1), (100, 128, 0, 1)] @?= [True, True, True, True]
+    map public [ (127, 0, 0, 1), (10, 1, 2, 3), (172, 16, 0, 1), (192, 168, 1, 1), (169, 254, 169, 254)
+               , (0, 0, 0, 0), (100, 64, 0, 1), (224, 0, 0, 1), (255, 255, 255, 255), (198, 18, 0, 1) ]
+        @?= replicate 10 False
+
+{-
+An import must be a .cfr file, and a URL import must not be served as a web page.
+-}
+case_ModelFilesOnly :: Assertion
+case_ModelFilesOnly = do
+    map isModelPath ["lib.cfr", "/models/design space.cfr"] @?= [True, True]
+    map isModelPath ["/etc/hostname", "/index.php", "lib.cfr.bak", ""] @?= replicate 4 False
+    map (isModelContentType . fmap fromString) [Nothing, Just "text/plain; charset=utf-8", Just "application/octet-stream"]
+        @?= [True, True, True]
+    map (isModelContentType . Just . fromString)
+        ["text/html", "Text/HTML; charset=UTF-8", "application/json", "application/problem+json", "application/xml", "image/svg+xml"]
+        @?= replicate 6 False
+
+{-
+An import is relative to the importing file: to its folder, or to its URL. A
+file:// URL is a local path, and a model read from a URL can only import URLs.
+-}
+case_ImportLocations :: Assertion
+case_ImportLocations = do
+    let url = fromJust . parseURI
+        systemURL = Remote $ url "https://example.org/models/system.cfr"
+    location "file:///tmp/a%20b.cfr" == Local "/tmp/a b.cfr" @? "file:// URL"
+    location "http://example.org/a.cfr" == Remote (url "http://example.org/a.cfr") @? "http:// URL"
+    importLocation (Local "models/system.cfr") "lib/base.cfr" == Right (Local "models/lib/base.cfr") @? "relative to a folder"
+    importLocation (Local "system.cfr") "../base.cfr" == Right (Local "../base.cfr") @? "relative to the current folder"
+    importLocation systemURL "lib/base.cfr" == Right (Remote $ url "https://example.org/models/lib/base.cfr") @? "relative to a URL"
+    importLocation systemURL "../shared/base.cfr" == Right (Remote $ url "https://example.org/shared/base.cfr") @? "a parent of a URL"
+    importLocation systemURL "design space.cfr" == Right (Remote $ url "https://example.org/models/design%20space.cfr") @? "a space in a URL"
+    importLocation (Local "system.cfr") "https://example.org/base.cfr" == Right (Remote $ url "https://example.org/base.cfr") @? "a URL from a local file"
+    isLeft (importLocation systemURL "/etc/hostname") @? "a local path from a URL"
+    isLeft (importLocation systemURL "file:///etc/hostname") @? "a file:// URL from a URL"
+  where
+    isLeft = either (const True) (const False)
+
+{-
+An abstract clafer which no concrete clafer extends is removed, unless a
+reference or a constraint names it: then it is kept, without instances.
+-}
+unusedAbstractModel :: String
+unusedAbstractModel = "abstract Property\nabstract Unused\nabstract Named\nComponent\n    properties -> Property *\n[ no Named ]"
+
+case_ReferencedUnusedAbstractKept :: Assertion
+case_ReferencedUnusedAbstractKept = do
+    let
+        results = fromRight $ compileOneFragment defaultClaferArgs{mode = [Alloy, Choco]} unusedAbstractModel
+        alloy = outputCode $ fromJust $ Map.lookup Alloy results
+        choco = outputCode $ fromJust $ Map.lookup Choco results
+    ("$Property = Abstract" `isInfixOf` choco) @? "Choco: the referenced Property is not declared\n" ++ choco
+    ("$Named = Abstract" `isInfixOf` choco) @? "Choco: Named, used in a constraint, is not declared\n" ++ choco
+    not ("$Unused" `isInfixOf` choco) @? "Choco: the unused Unused is declared\n" ++ choco
+    ("abstract sig Property" `isInfixOf` alloy) @? "Alloy: the referenced Property is not declared\n" ++ alloy
+    ("fact { #Property = 0 }" `isInfixOf` alloy) @? "Alloy: Property may have instances\n" ++ alloy
+    not ("sig Unused" `isInfixOf` alloy) @? "Alloy: the unused Unused is declared\n" ++ alloy
+
+-- The integer range of the Choco output can be set with --minint and --maxint,
+-- also in //# OPTIONS; without them, chocosolver chooses it.
+case_ChocoIntRange :: Assertion
+case_ChocoIntRange = do
+    let
+        choco args' model' = outputCode $ fromJust $ Map.lookup Choco $ fromRight $ compileOneFragment args' model'
+        withOptions = "//# OPTIONS --minint=-500 --maxint=500\nx -> integer = 170\n"
+    ("intRange(-500, 500);" `isInfixOf` choco defaultClaferArgs{mode = [Choco]} withOptions) @? "OPTIONS ignored"
+    not ("intRange" `isInfixOf` choco defaultClaferArgs{mode = [Choco]} "x -> integer = 1\n") @? "Range set without options"
+    ("intRange(-128, 100);" `isInfixOf` choco defaultClaferArgs{mode = [Choco], maxint = Just 100} "x -> integer = 1\n") @? "--maxint ignored"
+
+-- After an explicit dref, the names are the children of the reference's target (#108):
+-- this.dref.speed means this.speed, in the static and the temporal generators.
+case_ExplicitDrefNavigation :: Assertion
+case_ExplicitDrefNavigation = do
+    let
+        output mode' constraint = fmap (outputCode . fromJust . Map.lookup mode') $ compileOneFragment defaultClaferArgs{mode = [mode']} $ unlines
+            [ "abstract Port"
+            , "    speed -> integer"
+            , "hub : Port"
+            , "l -> Port"
+            , "    " ++ constraint ]
+        same mode' a b = case (output mode' a, output mode' b) of
+            (Right a', Right b') -> a' == b' @? (show mode' ++ ": " ++ a ++ " differs from " ++ b)
+            (Left errs', _) -> assertFailure $ a ++ ": " ++ show errs'
+            (_, Left errs') -> assertFailure $ b ++ ": " ++ show errs'
+    forM_ [Alloy, Choco] $ \mode' -> do
+        same mode' "[ this.speed = 3 ]" "[ this.dref.speed = 3 ]"
+        same mode' "[ this.speed = 3 ]" "[ dref.speed = 3 ]"
+        same mode' "[ this.speed = 3 ]" "[ this.dref.speed.dref = 3 ]"
+    same Alloy "[ G this.speed = 3 ]" "[ G this.dref.speed = 3 ]"
+    case output Alloy "[ all t : this.dref | t.speed = 3 ]" of
+        Right _ -> return ()
+        Left errs' -> assertFailure $ show errs'
+
+-- The parent of an instance of a top-level clafer is the synthetic root, a navigation from which
+-- is a navigation from the top level (#112).
+case_ParentOfTopLevel :: Assertion
+case_ParentOfTopLevel = do
+    let
+        model constraint = unlines [ "a", "b", "    " ++ constraint ]
+        output mode' constraint = fmap (outputCode . fromJust . Map.lookup mode') $ compileOneFragment defaultClaferArgs{mode = [mode']} $ model constraint
+        same mode' x y = case (output mode' x, output mode' y) of
+            (Right x', Right y') -> x' == y' @? (show mode' ++ ": " ++ x ++ " differs from " ++ y)
+            (Left errs', _) -> assertFailure $ x ++ ": " ++ show errs'
+            (_, Left errs') -> assertFailure $ y ++ ": " ++ show errs'
+        refused x expected = case compileOneFragment defaultClaferArgs x of
+            Left errs' -> (expected `isInfixOf` show errs') @? ("Unexpected errors\n" ++ show errs')
+            Right _ -> assertFailure $ x ++ " compiled"
+    forM_ [Alloy, Choco] $ \mode' -> do
+        same mode' "[ some a ]" "[ some parent.a ]"
+        same mode' "[ some a ]" "[ some this.parent.a ]"
+        same mode' "[ some a ]" "[ some root.a ]"
+        same mode' "[ all v : b | some a ]" "[ all v : b | some v.parent.a ]"
+    same Alloy "[ G some a ]" "[ G some parent.a ]"
+    -- the root as a value is a constant: true as 0 < 1, false as 1 < 0, and 1 for #root
+    let contains mode' x expected = case output mode' x of
+            Right x' -> (expected `isInfixOf` x') @? (show mode' ++ ": " ++ x ++ " is not " ++ expected ++ "\n" ++ x')
+            Left errs' -> assertFailure $ x ++ ": " ++ show errs'
+    contains Alloy "[ some parent ]" "{ 0 < 1 }"
+    contains Alloy "[ no root ]" "{ 1 < 0 }"
+    contains Alloy "[ #this.parent = 1 ]" "{ 0 < 1 }"
+    contains Choco "[ some parent ]" "lessThan(constant(0), constant(1))"
+    -- the parent of a set of instances of a top-level clafer is the root when an instance exists
+    let optional constraint = unlines [ "a ?", "b", "    " ++ constraint ]
+        sameOptional mode' x y = case (compile' mode' x, compile' mode' y) of
+            (Right x', Right y') -> x' == y' @? (show mode' ++ ": " ++ x ++ " differs from " ++ y)
+            (Left errs', _) -> assertFailure $ x ++ ": " ++ show errs'
+            (_, Left errs') -> assertFailure $ y ++ ": " ++ show errs'
+        compile' mode' = fmap (outputCode . fromJust . Map.lookup mode') . compileOneFragment defaultClaferArgs{mode = [mode']} . optional
+    forM_ [Alloy, Choco] $ \mode' -> do
+        sameOptional mode' "[ some a ]" "[ some a.parent ]"
+        sameOptional mode' "[ no a ]" "[ no a.parent ]"
+    case compile' Alloy "[ some a.parent.a ]" of
+        Right x' -> ("some ((some a) => (a) else none)" `isInfixOf` x') @? x'
+        Left errs' -> assertFailure $ show errs'
+    refused (unlines [ "abstract Feat", "f1 : Feat", "g", "    f2 : Feat", "[ all v : Feat | some v.parent ]" ]) "take the parent of `this`"
+    -- some subclafers of Feat are at the top level and some nested: its constraint is split on this
+    case compileOneFragment defaultClaferArgs{mode = [Alloy, Choco]} (unlines [ "abstract Feat", "    [ some parent ]", "f1 : Feat", "g", "    f2 : Feat" ]) of
+        Right r -> do
+            let alloy = outputCode $ fromJust $ Map.lookup Alloy r
+                choco = outputCode $ fromJust $ Map.lookup Choco r
+            ("((this in f1) => (0 < 1)) && ((this in (g.@r_f2)) => (some (this & (g.@r_f2)).~(@r_f2)))" `isInfixOf` alloy) @? alloy
+            ("joinParent(inter($this(), join(global($g), $f2)))" `isInfixOf` choco) @? choco
+        Left errs' -> assertFailure $ show errs'
+
+-- final, finalref and finaltarget on a clafer that inherits its reference fix the reference in
+-- the temporal output (#109).
+case_FinalInheritedReference :: Assertion
+case_FinalInheritedReference =
+    forM_ ["final", "finalref", "finaltarget", ""] $ \modifier ->
+        case compileOneFragment defaultClaferArgs{mode = [Alloy]} (unlines
+                [ "abstract Engine", "gas : Engine", "abstract Car", "    abstract engine -> Engine"
+                , "    xor gear", "        initial park --> drive", "        drive"
+                , "tesla : Car", "    " ++ modifier ++ " motor : engine" ]) of
+            Right r -> let alloy = outputCode $ fromJust $ Map.lookup Alloy r
+                           -- final and finalref fix the reference of each motor, finaltarget the
+                           -- targets of the motors of a tesla (kbak/clafer-semantics#127)
+                           eachFixed = "implies (this.@engine_ref)' = this.@engine_ref)" `isInfixOf` alloy
+                           targetsFixed = "implies (this.@r_motor.@engine_ref)' = this.@r_motor.@engine_ref)" `isInfixOf` alloy
+                       in (eachFixed, targetsFixed) == (modifier `elem` ["final", "finalref"], modifier == "finaltarget")
+                            @? (modifier ++ ": " ++ alloy)
+            Left errs' -> assertFailure $ modifier ++ ": " ++ show errs'
+
+-- A clafer which extends itself is reported as such, not as a missing super.
+case_SelfInheritanceReported :: Assertion
+case_SelfInheritanceReported =
+    case compileOneFragment defaultClaferArgs "abstract A : A\nb : A" of
+        Left errs' -> ("inherits from itself" `isInfixOf` show errs') @? "Unexpected errors\n" ++ show errs'
+        Right _ -> assertFailure "abstract A : A compiled"
+
+-- The initializer := is the initial value of a reference (kbak/clafer-semantics#164): the same as
+-- = in a static model, and the value in the first state of each lifetime of the clafer in a
+-- temporal model. It is no longer an assertion (#116).
+case_InitialValue :: Assertion
+case_InitialValue = do
+    let
+        output modes' model = fmap (\r -> map (\m -> outputCode $ fromJust $ Map.lookup m r) modes') $ compileOneFragment defaultClaferArgs{mode = modes'} $ unlines model
+        static' how = [ "A 2", "    x -> integer " ++ how ++ " 10", "    y -> integer ? " ++ how ++ " x + 1"
+                      , "    zs -> integer 0..2 " ++ how ++ " 1, 2", "abstract Val -> integer " ++ how ++ " 2", "v1 : Val" ]
+        explicit model = case output [Clafer] model of
+            Right [x] -> return x
+            Right _ -> assertFailure "no explicit model" >> return ""
+            Left errs' -> assertFailure (show errs') >> return ""
+        has model expected = do
+            x <- explicit model
+            (expected `isInfixOf` x) @? (expected ++ " not in\n" ++ x)
+    -- a static model: the same outputs as with =, and no assertion
+    case (output [Alloy, Choco, Clafer] $ static' ":=", output [Alloy, Choco, Clafer] $ static' "=") of
+        (Right a, Right b) -> do
+            a == b @? ("differs from =:\n" ++ unlines a)
+            not (any ("assert" `isInfixOf`) a) @? ("an assertion:\n" ++ unlines a)
+            not ("--tl" `isInfixOf` last a) @? ("temporal:\n" ++ last a)
+        (Left errs', _) -> assertFailure $ show errs'
+        (_, Left errs') -> assertFailure $ show errs'
+    -- a temporal model: in the context of x, with the value resolved in the context of the parent
+    let temporal = [ "A", "    y -> integer", "    x -> integer ? := y + 1", "        y -> integer"
+                   , "    z -> integer := this.y", "    zs -> integer * := 1, 2", "finalref f -> integer ? := A.y"
+                   , "[ F some A.x ]" ]
+    has temporal "0..* x -> int 0..1 {\n    [initially (this.dref = (this.parent.A__y.dref + 1))]"
+    has temporal "0..* z -> int 1..1 {\n    [initially (this.dref = this.parent.A__y.dref)]"
+    has temporal "[initially (((#this.zs) >= 1) => (this.zs.dref = (1 ++ 2)))]"
+    -- a finalref reference keeps the value it starts with, also when the value of A.y changes
+    has temporal "finalref 0..* f -> int 0..1 {\n  [initially (this.dref = A.A__y.dref)]"
+    x <- explicit temporal
+    not ("assert" `isInfixOf` x) @? ("an assertion:\n" ++ x)
+
+-- The Alloy output of a model, static or temporal.
+alloyOf :: [String] -> Either String String
+alloyOf model = case compileOneFragment defaultClaferArgs{mode = [Alloy]} $ unlines model of
+    Right r -> Right $ outputCode $ fromJust $ Map.lookup Alloy r
+    Left errs' -> Left $ show errs'
+
+hasAlloy :: [String] -> String -> Assertion
+hasAlloy model expected = case alloyOf model of
+    Right alloy -> (expected `isInfixOf` alloy) @? (expected ++ " not in\n" ++ alloy)
+    Left errs' -> assertFailure errs'
+
+lacksAlloy :: [String] -> String -> Assertion
+lacksAlloy model unexpected = case alloyOf model of
+    Right alloy -> not (unexpected `isInfixOf` alloy) @? (unexpected ++ " in\n" ++ alloy)
+    Left errs' -> assertFailure errs'
+
+-- A := under an inherited = is reported as an initializer that does not redefine the =, not as
+-- one without effect: an equal value repeats it, another one leaves no instance, which forces an
+-- optional clafer to be absent (#124).
+case_InitializerUnderInheritedConstant :: Assertion
+case_InitializerUnderInheritedConstant =
+    forM_ ["r : Ref := 2", "r : Ref := 3", "r : Ref ? := 3"] $ \sub ->
+        case compileOneFragment defaultClaferArgs{mode = [Alloy]} (unlines [ "abstract Ref -> integer = 2", sub ]) of
+            Right r -> do
+                let stats = statistics $ fromJust $ Map.lookup Alloy r
+                ("the initializer ':=' of r does not redefine the initializer '=' of Ref, which r inherits: both hold" `isInfixOf` stats) @? (sub ++ ": " ++ stats)
+                not ("no effect" `isInfixOf` stats) @? (sub ++ ": " ++ stats)
+            Left errs' -> assertFailure $ sub ++ ": " ++ show errs'
+
+-- A reference that refines an inherited one has the target of the inherited one in the temporal
+-- output, as in the static one (#120).
+case_RefinedReferenceTemporal :: Assertion
+case_RefinedReferenceTemporal =
+    hasAlloy [ "abstract Ref -> integer", "r : Ref -> integer", "[ G (r.dref = 1) ]" ]
+        "always (this in alive_r implies (this.@r_ref in this.@Ref_ref))"
+
+-- The set reference keys (#121, #125): per parent, for the reference a concrete clafer inherits
+-- too, and none for a top-level abstract clafer, in both outputs; none for a bag reference.
+case_SetReferenceKeys :: Assertion
+case_SetReferenceKeys = do
+    let model = [ "Target 2", "abstract Ref -> Target", "r : Ref 2", "a : Ref", "c : Ref"
+                , "abstract BagRef ->> Target", "b : BagRef 2" ]
+    hasAlloy model "all disj x, y : r | (x.@Ref_ref) != (y.@Ref_ref)"
+    lacksAlloy model "all disj x, y : Ref"
+    lacksAlloy model "all disj x, y : b"
+    hasAlloy (model ++ ["[ G some r ]"]) "all disj x, y : this.@r_r | (x.@Ref_ref) != (y.@Ref_ref)"
+    lacksAlloy (model ++ ["[ G some r ]"]) "all disj x, y : this.@r_b"
+
+-- An instance has no reference while it does not exist (#122).
+case_AbsentReference :: Assertion
+case_AbsentReference = do
+    hasAlloy [ "x -> integer ?", "[ G some x ]" ] "always (this not in alive_x implies no this.@x_ref)"
+    -- an inherited reference: the instances of the abstract clafer are those of its subclafers
+    hasAlloy [ "abstract Ref -> integer", "r : Ref ?", "[ G some r ]" ] "always (this not in alive_Ref implies no this.@Ref_ref)"
+
+-- The value of an initializer with temporal operators is evaluated in the context of the parent
+-- (#123): its obligation is bounded by the parent of the parent, the root here, so it has no
+-- guard, and it navigates from the parent, also after the parent disappeared.
+case_InitialValueTemporalContext :: Assertion
+case_InitialValueTemporalContext = do
+    let model inner = [ "P ?", "    Box ?", "        flag ?", "        x -> integer := if " ++ inner ++ " then 1 else 2"
+                      , "[ initially (some P.Box && X no P.Box) ]" ]
+    hasAlloy (model "X (some flag)") "after (not some (self_.(@p_x)).(@p_Box :> alive_P) or (some (self_.(@p_x :> alive_Box)).@r_flag))"
+    hasAlloy (model "initially (some flag)") "(not before (self_.(@p_x)) in alive_Box) implies"
+    -- without temporal operators, the value is the same as before
+    hasAlloy (model "some flag") "((some (self_.(@p_x :> alive_Box)).@r_flag) => 1 else 2)"
